Curia.

Governance + orchestration for multi-model engineering

Governed collaboration for software engineering agents.

Curia connects agents, decisions, and execution—from the first discussion to the final code change.

See how agents collaborate Watch the staged demo

Built by Adeilson Brito

CURIA / 0.1.0EARLY-STAGE EXPERIMENT
FIG. 01STAGED EXECUTION
CCodex
Independent proposal
AClaude
Independent proposal
GGrok
Independent proposal
1
2
3
REDUCERRank proposals
review, select,
or request changes
Human gate
decision authority
stays with you
✦
ONE WRITERPen-holder applies

Diverse proposals. Deliberate choice. Controlled change.

01 / THE PREMISE

The question is not how many agents can run.

It is how they should collaborate. Curia is the governance and orchestration layer for multi-model software engineering—applying AI systems engineering principles to connect agents, decisions, and execution from the first discussion to the final code change.

02 / WAYS TO COLLABORATE

Change the geometry without leaving the conversation.

Start focused. Add perspectives only when they improve the decision. Authority stays explicit throughout.

01FOCUSED

Drive with one agent

Work naturally with the pen-holder, as you would with a single coding agent. The rest of the council stays quiet until invited.

curia "review this module"
02ON DEMAND

Call in a specialist

Summon any agent to review, criticize, or contribute. It enters read-only and receives the conversation it missed.

@codex challenge this approach
03CUMULATIVE

Convene the round table

Every running agent answers in turn. Each can build on, refine, or disagree with the perspectives already heard.

/roundtable on
04INDEPENDENT → GATED

Run a Stage

Generate independent proposals, rank them, choose at a human gate, and let exactly one pen-holder apply the decision.

/stage <objective>

ONE SUBSTRATE Persistent agent sessions · shared conversation context · one rotating pen

03 / STAGES

From uncertainty to one governed change.

Stages is designed for high-stakes choices—architecture, root cause, migration—not every small edit.

  1. 01

    READ-ONLY · CONCURRENT

    Propose independently

    Every running agent receives the same frozen starting context. Peer outputs stay hidden during the stage, reducing anchoring.

  2. 02

    READ-ONLY · CUMULATIVE

    Rank addressable artifacts

    A reducer consumes the complete proposal set and returns a structured order with visible rationale—never a silent consensus.

  3. 03

    HUMAN AUTHORITY

    Choose at the gate

    You inspect the candidates, select any proposal, or stop. Approval captures a workspace fingerprint before writing begins.

  4. 04

    SERIALIZED · WRITE

    Apply with one pen-holder

    Curia verifies that the workspace has not moved. Exactly one living agent process receives the selected artifact and applies it.

04 / PRODUCT DIRECTION

From collaboration to governed software delivery.

IN DEVELOPMENT

Built on Curia capabilities available today.

Curia is evolving beyond individual multi-agent interactions into a continuous workflow that carries context, decisions, assumptions, and unresolved questions across the software-delivery lifecycle.

  1. 01Discuss
  2. 02Specify
  3. 03Plan
  4. 04Implement
  5. 05Review
  6. 06Validate
  7. 07Integrate
  8. 08Prepare PR

Different agents and models can contribute where they are strongest while Curia preserves shared context, exposes disagreement, controls authority and transitions, enforces independent review, and maintains traceability from decision to code.

The direction is model-independent: frontier models, commercial providers, compatible open-weight or local deployments, and specialized coding agents can operate as one governed engineering system.

NOW

Governed collaboration

Shared sessions, on-demand consultation, Roundtable, controlled pen transfer, and gated Stages.

NEXT

Continuous workflow

Persistent flow across specification, implementation, review, security validation, and PR preparation.

LATER

Organizational control plane

Reusable policies, cost-aware model assignment, isolated parallel implementation, and richer provenance.

05 / COLLABORATION GEOMETRY

Not another name for “parallel agents.”

INDEPENDENT PARALLELISM

Many threads.
Many workspaces.

  • Divide a backlog
  • Isolate edits with worktrees
  • Human coordinates separate tasks

CURIA

One objective.
A governed council.

  • Call any agent into the conversation
  • Deliberate together or propose independently
  • One controlled writer across every mode

Curia also supports cumulative Roundtable discussion. Stages adds a different geometry: independent within a stage, cumulative across stages.

06 / DEMONSTRATION

THE TEST CASE

A cancellation race with no obvious fix.

A small TypeScript scheduler lets late workers publish artifacts after a run is cancelled. Several solutions look plausible; only some close the race without breaking subsequent runs.

Watch the Stage workflow 
$ /stage Diagnose and fix the cancellation race.

Requirements:
  no late writes after cancellation
  preserve concurrent execution
  deterministic regression tests
  no new dependencies
BEFORElate completion mutates store→AFTERlate completion rejected; next run clean

07 / UNDER THE HOOD

ACP is the governance layer.

Curia is an ACP client—not a wrapper around stateless CLI calls. Persistent per-agent sessions and structured actions make collaboration observable and governable.

01

Persistent sessions

Each CLI agent stays alive across turns, preserving its own session context.

02

Shared context

Per-agent delivery cursors provide the conversation each participant missed—without duplicating what it already knows.

03

Permission mediation

Non-pen write and command requests are denied over ACP, backed by agent modes where available.

04

Workspace integrity

A gate records the decision; a separate fence detects if the tree moved before apply.

SUPPORTED HARNESS FAMILIESClaudeCodexClineGrok

08 / HONEST BOUNDARIES

Early-stage, by design and by disclosure.

Curia is currently version 0.1.0 and the repository remains private while the architecture is validated. Its orchestration engine is tested with a mock ACP agent, with live CLI compatibility probes also performed.

Read-only enforcement is cooperative and best-effort—not a hard security sandbox. The gate is not a lock; the workspace fence detects external change and sends the decision back for review.