a meta-harness for LLM agents

One conversation.
As many agents as the work needs.

Sirene is a terminal app for orchestrating LLM agents. Talk to a chat agent for ad-hoc work. Let it spawn a fleet of subagents across models and worktrees. Check the patterns that work into version control as Starlark workflows, and run them anywhere.

early access see a workflow

what's inside

A harness for building harnesses.

Sirene is an agent harness in its own right — and the toolkit for building the domain-specific one your team actually needs. Every agent runs on the same machinery, stays addressable, and can pick up new work after its first job is done.

a chat agent that lives in your terminal

Streaming chat with tool calls, slash commands, session resume, and a live inspector for every agent, channel, and memory in play. Built on Bubble Tea.

workflows as code

Multi-agent pipelines are checked-in Starlark files. Sequential, parallel, fan-out/fan-in, debate, iterative refinement — any shape you can write as a script.

subagents in isolated worktrees

The chat agent spawns workers on whatever models fit the job. Each gets its own git worktree, tool grant, and sandbox, so a parallel fleet never clobbers itself.

memory that outlives the session

Seshat watches your conversations and files what matters. Thoth consolidates the store between sessions. Tell sirene something once; it stays told.

agents that talk to each other

Typed channels with JSON schemas, and a claim-post-release blackboard for shared state. Coordination is a primitive, not a prompt-engineering trick.

headless when you need it

sirene --workflow <name> runs any pipeline from CI, a cron job, or another coding agent. Every run leaves a JSONL event trail you can replay.

drive it from outside

The MCP bridge turns a live session into an orchestration surface for Claude Code, Codex, or anything that speaks MCP. Drivers come and go; subagents keep working.

bring your own subscription

Authenticated Claude, Codex, and Muse CLIs are preferred where they match. Anthropic, OpenAI, and OpenRouter APIs sit behind an explicit billing policy.

context that never falls off a cliff

Long conversations compact automatically near the window limit. Old turns are offloaded, not deleted, and every compaction can be rolled back.

workflows

Pipelines are just scripts.

Three reviewers critique a diff in parallel; a lead synthesizes their findings. Each agent is a folder with an AGENT.md system prompt and Markdown prompt templates.

Run it inside the TUI and watch every agent stream live in the inspector, or run it headless with sirene --workflow review. Completed steps short-circuit on resume, so a crashed run picks up where it fell over.

DESCRIPTION = "Three reviewers critique a diff in parallel; a lead synthesizes."

def run(args):
    diff = exec(command="git", args=["diff", "main"])["stdout"]

    reviewer = Agent(name="reviewer", model="anthropic/claude-sonnet-4-6")
    lead     = Agent(name="lead", model="anthropic/claude-opus-4-7")

    reviewers = reviewer.spawn(3)
    handles = [
        r.run(prompt="review.md", prompt_vars={"diff": diff})
        for r in reviewers
    ]
    results = await_agents(handles)
    reviews = {results[h]["agent"]: results[h]["output"] for h in handles}

    h = lead.run(prompt="synthesize.md", prompt_vars=reviews)
    verdict = await_agents([h])[h]["output"]
    save_to_session(filename="review.md", content=verdict)

how it fits together

Small pieces, sharp edges.

              ┌───────────────────────────────────────────┐
              │  chat agent  ← your persistent conversation
              └────┬──────────────────────────────────────┘
                   │ tool calls
        ┌──────────┼────────────────────────────────────────┐
        │          │                                        │
        ▼          ▼                                        ▼
   subagents   channels · blackboard              memory (SQLite)
   (workers)   (agent ↔ agent IPC)                 · scopes
        │                                          · Seshat  (in-session observer)
        ▼                                          · Thoth   (cross-store consolidator)
   worktrees                                       · compaction (context management)
   (isolated
    filesystems)
    ▲                             ▲
    │                             │
   .star workflow             MCP bridge (external clients: claude code, codex)
   (checked-in DAG)

try this first

What it feels like.

three reviewers, one diff

One prompt spawns three reviewers on three models. They post findings to a schema-validated channel; the chat agent synthesizes a verdict.

watch the DAG

Run a workflow and open the inspector: the step graph renders live, parallel branches and all. A failed step can be retried, skipped, or resumed later.

it remembers

Mention "we never use ORMs here" in passing. Quit. Start fresh tomorrow and ask for a data-access layer. The rule surfaces without you repeating it.

early access

In private alpha.

Sirene is in use by a small group while it settles. If you have access, the repository README walks you through the install, and the full user guide ships inside the binary.