Timeline and Dependencies

This document maps dependencies between epics and tasks across all Agent Architecture projects. Use this to identify the critical path, parallel work opportunities, and blocking relationships.

---

---

Epic-to-Epic Dependencies

Critical Path (must be built in order)

Session State Management
        │
        ▼
Tool Cascade (Internal Context Loading)
        │
        ▼
LLM Orchestration Loop
        │
        ▼
Queue Implementation
        │
        ▼
Worker Process Lifecycle
        │
        ▼
Agent Abstraction Layer
        │
        ▼
Dining Research Agent (Vertical 1)
        │
        ▼
Additional Verticals (Experiences, Transportation, Flights, DMC)

Dependency Matrix

Epic	Depends On	Blocked By	Enables
Orchestrator Core Engine
Session State Management	—	—	Tool Cascade, LLM Loop
Tool Cascade	Session State Management	—	LLM Loop
LLM Orchestration Loop	Session State Management, Tool Cascade	—	Queue Implementation (dispatch side)
Job Queue Infrastructure
Queue Implementation	—	—	Worker Process Lifecycle, Agent Abstraction
Queue Monitoring	Queue Implementation	—	Scaling (autoscaling signal)
Research Agent Framework
Worker Process Lifecycle	Queue Implementation	—	Agent Abstraction, all vertical agents
Agent Abstraction Layer	Worker Process Lifecycle	—	Dining Agent, all vertical agents
Dining Research Agent	Worker Process Lifecycle, Agent Abstraction	—	Additional Verticals
Experiences Research Agent	Worker Process Lifecycle, Agent Abstraction	—	—
Transportation Research Agent	Worker Process Lifecycle, Agent Abstraction	—	—
Flights Research Agent	Worker Process Lifecycle, Agent Abstraction	—	—
DMC Research Agent	Worker Process Lifecycle, Agent Abstraction	—	—
Scaling and Reliability
Orchestrator Scaling	Session State Management	—	Production readiness
Agent Autoscaling	Queue Monitoring, Worker Process Lifecycle	—	Production readiness
Failure Mode Handling	Queue Implementation, Worker Process Lifecycle	—	Production readiness
Observability and Operations
Distributed Tracing	Session State Management, Worker Process Lifecycle	—	Metrics and Alerting
Metrics and Alerting	Distributed Tracing, Queue Monitoring	—	Cost Telemetry
Cost Telemetry	Metrics and Alerting	—	—

---

Task-Level Dependencies Within Epics

Session State Management

Task	Depends On	Notes
Design session state schema	—	Start here
Implement in-memory working copy	Schema design
Define Postgres schema	Schema design	Parallel with in-memory
Set up Redis session store	Schema design	Parallel with Postgres
Implement session write-through	In-memory copy, Redis, Postgres	All three must exist
Build session reconstruction	Write-through
Implement sticky routing	Reconstruction
Build session migration	Sticky routing
Add session metrics	All above	Last task

Tool Cascade

Task	Depends On	Notes
Define tool interface contract	—	Start here
Implement Tier 1 tools	Contract	Parallel with Tier 2/3
Implement Tier 2 tools	Contract	Parallel with Tier 1/3
Implement Tier 3 tools	Contract	Parallel with Tier 1/2
Build cascade orchestrator	All tiers	Must have all three tiers
Implement brief generation	Cascade orchestrator
Add caching	All tiers	Can parallel with cascade
Build cascade error handling	Cascade orchestrator
Add cascade metrics	All above	Last task

LLM Orchestration Loop

Task	Depends On	Notes
Define decompose prompt	—	Start here
Implement decompose step	Prompt
Build dispatch logic	Decompose step
Implement parallel dispatch	Dispatch logic
Build synthesis step	Dispatch logic	Can parallel with dispatch
Implement re-planning	Synthesis step
Implement per-job timeout	Dispatch logic
Build partial result support	Timeout, Synthesis
Implement streaming response	Synthesis step
Build conversation history integration	Decompose step
Add LLM metrics	All above	Last task

Queue Implementation

Task	Depends On	Notes
Set up Redis instance	—	Start here
Define job payload schema	—	Parallel with Redis setup
Implement job enqueue function	Redis, Schema
Build per-agent queues	Enqueue function
Implement result storage	Redis
Build pub/sub notifications	Result storage
Implement Orchestrator subscriber	Pub/sub
Build dead-letter queue	Enqueue function
Implement job retry logic	Dead-letter queue
Add job TTL	Enqueue function
Build queue cleanup	TTL
Implement Redis connection pooling	Redis
Add Redis health check	Connection pooling

Worker Process Lifecycle

Task	Depends On	Notes
Define job payload schema	Queue Implementation schema	Reuse or extend
Implement Redis connection pool	Queue Implementation Redis
Implement blocking pop	Connection pool
Build job deserialization	Blocking pop
Build job execution pipeline	Deserialization
Implement result write-back	Execution pipeline
Build pub/sub notification	Write-back
Implement ack flow	Write-back
Implement nack flow	Write-back
Add visibility timeout	Ack/nack
Implement graceful shutdown	All above
Build health check endpoint	Connection pool
Build readiness check endpoint	All dependencies

Agent Abstraction Layer

Task	Depends On	Notes
Define input contract	Worker Process Lifecycle schema
Define output contract	Worker Process Lifecycle schema
Build worker process pool manager	Worker Process Lifecycle
Implement agent registration	Pool manager
Implement per-agent LLM config	Registration
Implement per-agent tool config	Registration
Build agent discovery	Registration
Add agent health monitoring	Pool manager
Build agent versioning	Registration
Implement agent isolation	Pool manager

Dining Research Agent

Task	Depends On	Notes
Set up Dining Agent container	Agent Abstraction
Integrate OpenTable API	Container	Parallel with other APIs
Integrate Resy API	Container	Parallel with other APIs
Integrate Yelp API	Container	Parallel with other APIs
Integrate Tock API	Container	Parallel with other APIs
Build source aggregation	All API integrations
Implement deduplication	Source aggregation
Define RestaurantOption schema	—	Can start early
Build dining system prompt	Schema
Implement latency budget	Source aggregation
Build caching layer	Source aggregation
Implement rate limiting	All API integrations
Add source health monitoring	All API integrations
Build output validation	Schema, Execution pipeline

---

Parallel Work Opportunities

Wave 1 (can start immediately)

• Session State Management (Orchestrator)
• Queue Implementation (Job Queue)
• Agent Abstraction Layer design (Research Agents)

Wave 2 (after Wave 1 foundations)

• Tool Cascade (needs Session State)
• Worker Process Lifecycle (needs Queue)
• Distributed Tracing (needs Session State + Worker)

Wave 3 (after Wave 2)

• LLM Orchestration Loop (needs Tool Cascade + Session State)
• Dining Research Agent (needs Worker + Abstraction)
• Queue Monitoring (needs Queue Implementation)
• Metrics and Alerting (needs Tracing + Queue Monitoring)

Wave 4 (after Wave 3)

• Additional Vertical Agents (needs Worker + Abstraction)
• Orchestrator Scaling (needs Session State)
• Agent Autoscaling (needs Queue Monitoring + Worker)
• Failure Mode Handling (needs Queue + Worker)
• Cost Telemetry (needs Metrics)

---

Critical Path Summary

The minimum viable path to a working Dining Agent:

1. Session State Management (Orchestrator)
2. Tool Cascade (Orchestrator)
3. Queue Implementation (Job Queue)
4. Worker Process Lifecycle (Research Agents)
5. Agent Abstraction Layer (Research Agents)
6. Dining Research Agent (Research Agents)
7. LLM Orchestration Loop (Orchestrator) — can parallel with 4-6
8. Basic Metrics (Observability) — can parallel with 4-6

Estimated critical path: ~6-8 weeks if fully staffed and unblocked.

---

Risk Areas

Risk	Impact	Mitigation
Redis setup blocks everything	High	Start Redis infrastructure immediately
Session State schema changes cascade	High	Finalize schema early, get sign-off
Partner API integration delays	Medium	Start with one API (OpenTable), add others incrementally
LLM prompt iteration takes longer than expected	Medium	Start decompose/synthesize prompts early, iterate
Tool Cascade complexity underestimated	Medium	Build tier by tier, test each independently