Frame
- Input
- Your raw task
- Output
- Scoped brief
Turns a loose request into scope, goal, constraints, and a concrete done condition before work starts.
Disciplined autonomy for coding agents.
Your agent follows a process instead of improvising on the spot. Less micro-managing, more working with a colleague you can trust.
Example Run
Most of us are steering our agents step-by-step in chat.
Circuit carries the process through the run.
$ /circuit:run build the Circuit landing page from the outline
CIRCUIT⎿ Chose build.⎿ Framing the work...⎿ Planning the work...⎿ Asking the specialist to make the change...⎿ Finished the specialist pass.⎿ Checking the work...⎿ Build complete. Verification passed, review accepted.
You describe the task
You can focus on the goal rather than the precise means.
Circuit selects the flow
The right process is inferred and recorded.
It follows the process
Plan -> change -> check -> review.
Result with evidence
A verified result, with the trace to back it: what changed and the checks that passed. No gaslighting.
Why Process
Great engineers don't rely on raw talent.
They work through a process they trust, and that process is what lets their judgment do its best work. It frees them to stop re-deciding the basics and spend attention where it matters.
Coding agents are surprisingly capable, but like humans, ad-hoc chat isn't the best way to do effective work. You become the agent's working memory. This is taxing for you, and a suboptimal experience for the agent that puts it at a disadvantage.
Circuit sets agents up for success.
The agent is the capable part. Circuit is the path it runs along. You describe the task, and Circuit supplies the process that fits it: the right moves, in the right order, with the checks that prove the work. You hand off more and keep your confidence, because the result comes with evidence, not just a claim that it's done.
Flexible, Not Rigid
/circuit:run starts with the flow that fits the task, but a flow is not a rigid script. When the work calls for it, supported flows can change rigor, continue autonomously with bounded recovery, or fan out into tournament mode. The blocks stay typed, so flexibility stays visible.
Build
Turn a clear brief into a reviewed change, backed by evidence.
- Frame
- Plan
- Act
- Run Verification
- Review
- Close With Evidence
Build runs lite to deep, and can run autonomously with bounded recovery attempts.
Inside a Block
Blocks are the power units inside every flow. Each one has a typed input, a typed output, and a clear job, so flows can combine them without losing track of what the agent knows.
Gather Context
- Input
- Brief plus repo signals
- Output
- Relevant context
Finds the files, docs, errors, prior decisions, and live state that should shape the next move.
Diagnose
- Input
- Context packet
- Output
- Cause and confidence
Separates symptoms from cause, names the likely failure mode, and keeps uncertainty visible.
Human Decision
- Input
- A real fork in the work
- Output
- User decision
Pauses only when judgment changes the result: tradeoffs, taste calls, risky scope, or missing intent.
Plan
- Input
- Brief and context
- Output
- Work strategy
Chooses the path, order, verification points, and handoffs before the agent starts changing things.
Coordinate
- Input
- Several related goals
- Output
- Dependency map
Keeps multi-part work legible by tracking dependencies, parallelizable chunks, and shared evidence.
Act
- Input
- Plan strategy
- Output
- Changed work
Makes the change and records what moved, why it moved, and what evidence the next block needs.
Run Verification
- Input
- Change evidence
- Output
- Check results
Runs the checks that fit the work and reports the command, result, and any remaining risk.
Review
- Input
- Change plus evidence
- Output
- Review verdict
Checks behavior, scope, and evidence from a separate review posture before the run calls itself done.
Close With Evidence
- Input
- The final verdict
- Output
- Final report
Leaves a short outcome with evidence pointers, decisions, residual risks, and the final status.
Custom
soonAuthor your own blocks with typed inputs and outputs, then compose them into new flows. Block and flow authoring is on the way.
Why You Can Trust It
Evidence
Circuit keeps checks and results attached to the work. The agent evaluates its own work against that evidence instead of asking you to take it on faith.
Checkpoints
Circuit pauses when your judgment changes the outcome: a risky direction, an ambiguous goal, a visual choice. The pause is part of the flow, not the agent's discretion. Otherwise it keeps moving.
Confidence
The point is confidence while you delegate more: Circuit keeps the process explicit, the evidence attached, and the outcome honest.
Memory
soonEvery run generates structured, CLI-queryable records: choices, checks, evidence, and what happened next. These form a powerful substrate for longitudinal memory.
Where It Fits
Circuit overlaps with tools and approaches you already use, but it solves a different problem. Those tools shape what the agent can do; Circuit shapes how the work moves from request to evidence-backed outcome.
Prompting + Skills
Skills give the agent stronger moves: read a trace, write a test, inspect a browser, review a diff. You still decide which move to call, when to call it, and when enough evidence exists.
How Circuit differs
Circuit uses those moves inside a flow. It routes the task, chooses the next block, carries context forward, and asks for your judgment only when the result depends on it.
AGENTS.md and Playbooks
Rules, docs, and saved prompts tell the agent what good work should look like. They are useful context, but they mostly sit still until you remember to apply them.
How Circuit differs
Circuit turns the playbook into motion. Each block has an input, output, and done condition, so the process produces evidence instead of relying on memory and vibes.
Spec-driven development
Write a detailed spec and the agent implements against it. The spec captures intent well, but it stays a document. It does not carry the work through building, checking, and review.
How Circuit differs
Circuit treats the spec as one input. Frame turns intent into a typed brief, then the flow carries it forward through plan, act, verify, and review until the outcome is backed by evidence.
Claude Code's Dynamic Workflows
Workflows orchestrate many agents from a script. They are great for large one-off jobs: codebase audits, migrations, deep research, or hand-rolled fanout.
How Circuit differs
Circuit is the repeatable process for everyday work. It picks Build, Fix, Review, Explore, Prototype, or Pursue, then runs the same proven process without making you design the orchestration.
Autonomous coding agents
Agents like Cursor, Devin, or Copilot's agent take a task and run it end to end. They are powerful, but each run is shaped by the prompt, so what they do and how rigorously they do it varies.
How Circuit differs
Circuit is not another agent. It is the process your agent follows: running inside Claude Code or Codex, it moves the same kind of work the same way every time, with evidence to show for it.
Compound engineering
A philosophy: each task should leave the system smarter, so the next one is easier, through planning, parallel review, and documenting what worked. You assemble that loop yourself, task by task.
How Circuit differs
Circuit is that loop, productized. Every flow already plans, acts, reviews, and checks, and each run leaves structured records: the substrate that longitudinal memory builds on.
Get Started
Install Circuit once for the agent you use.
Let your agent install it
Claude Code
› /plugin marketplace add petekp/circuit
› /plugin install circuit@circuit
› /reload-pluginsCodex
› codex plugin marketplace add petekp/circuit --ref circuit--v0.1.0-alpha.6OpenCode
SoonOpenCode support coming soon.