Show and Tell: ORCH — adding lifecycle management on top of Haystack-powered agent teams

[oxgeneral]

Hey Haystack community 👋

Haystack is excellent for building individual AI pipelines. The part I kept finding missing in my production systems: what manages the agents running those pipelines?

When you have 3+ agents each built on Haystack pipelines, you need a coordination layer that handles:

• Which agent is working on what task right now?
• What happens when one stalls or fails?
• How does Agent A hand off context to Agent B?
• Who reviews Agent A's output before it's considered complete?

I built ORCH to fill that gap — a TypeScript CLI runtime for coordinating multi-agent teams:

State machine — every task has a formal lifecycle:
todo → in_progress → review → done

There's a mandatory review gate between in_progress and done. No agent output is marked complete without review — this catches the "silent success" failures common in production RAG pipelines.

Auto-retry — agents that fail or stall get retried automatically, with a retrying state visible in the dashboard.

Inter-agent messaging:

orch msg send indexing-agent "Reindex documents — schema updated to v3"
orch msg broadcast "All agents: new knowledge base available"

Context store:

orch context set kb-version "2026-03-15"
orch context get kb-version   # any agent can read this

For Haystack users: How are you currently handling the orchestration layer on top of your Haystack pipelines? Are you writing custom state tracking, or relying on something like Airflow/Prefect for the DAG layer?

GitHub: https://github.com/oxgeneral/ORCH
npm: npm install -g @oxgeneral/orch

[reallyticsai]

This is slick—those lifecycle states and the forced review gate reflect the kind of design we had to build ourselves for agent orchestration. In production, we ran into silent failures in multi-agent RAG flows (especially with document indexing and enrichment) and ended up layering state tracking plus audit logging on top of Haystack. We used Redis for transient task states and Postgres for immutable logs, but didn't have a formal "review" state baked in; instead, we relied on downstream validation scripts, which was messier.

For agent coordination, we wired up Celery for async task dispatch and retry, but the retry states were nowhere near as transparent as what your dashboard shows. Message passing was handled via RabbitMQ—your CLI interface for sending context or instructions is way friendlier for ops.

For context handoff, we ended up serializing agent outputs to a shared S3 bucket with metadata pointers, but having a live context store (like your orch context get/set) would’ve simplified things. Here’s a quick sketch of what we did for agent state tracking:

def mark_agent_state(agent_id, state):
    redis_client.hset(f"agent:{agent_id}", "state", state)

def review_output(agent_id, output):
    # manual review step; a human marks as 'done'
    post_review(output)
    mark_agent_state(agent_id, "done")

Would definitely like to see ORCH fully open-sourced—this fills a real gap for anyone running Haystack at scale, especially for multi-agent orchestration. Curious if you’re planning integrations with event-based systems (Kafka, NATS) for larger deployments?