What ConflabCode is

ConflabCode puts two AI coding agents, Claude Code and Codex, on the same project at the same time, with you directing. Here is what that means in practice:

Two agents in the same conversation, not two sessions passing notes. Claude and Codex sit in the room together, trained differently, so they catch different mistakes the way a single agent working alone would not. Talk to both at once, or target one directly by clicking its window, naming it by name in your message, or locking a target with a right click. Whatever one agent says, the other sees on the next round, clearly marked as context to be aware of, not an instruction to follow.

Context that manages itself. Normally, you watch context usage and save it yourself before you hit the wall. On ConflabCode, nobody watches the gauge. Set a threshold per model, a lower percentage for a huge context window where context rot and higher cost creep in, a higher percentage for a smaller one, and when that threshold is hit, ConflabCode promotes a fresh agent instance and hands off the history invisibly. You stop thinking about context entirely.

Flexible enough to match how you actually work. Say "move this button seven pixels right" and the lead just does it, no ceremony required, with review always one click away. For a handful of loose objectives, free form mode runs them through design review, implementation, and verification automatically, with a single click.

Real cross-review, enforced by the stages themselves. For even more structure, brainstorm, design, implementation, verification, every stage lets you assign a lead and a reviewer, and you can swap roles at each stage, so Claude designs and Codex builds, then Claude reviews the code Codex just wrote. The stage itself makes sure of it.

Provenance that survives every handoff. Design items trace back to the brainstorm notes and rounds that produced them. Implementation traces back to design. Verification checks against all of it. At every stage, the reviewer isn't just checking whether the agent did what it said it would do, it's checking against your original intent, with an actual link back to where that intent came from. The more detail you give it, the sharper the result, thin notes still get you thin results, and the structure is there for you to take advantage of.

One click to reach consensus. It orients both agents on the same page, each catching what the other missed, and merges their input into a consolidated opinion you can act on. Neither agent holds the whole picture alone, so pooling what each one sees, even from the same context, catches more than either would catch working solo.

Built to run more than one pair of agents at once. Run up to ten ConflabCode instances at the same time, more than enough for any situation. Additionally, ConflabCode provides shiny new tools to replace the agents' original ones. Every mistake an agent makes normally costs a round trip to the provider, and that adds up fast. Each trip re-sends a full copy of context, costing time and money. ConflabCode's tools catch and retry the errors, self-correcting until it actually works. Things like quoting mistakes, wrong paths, and edits that need another pass all get fixed automatically.

Behavior Policy and Rules you control. Behavior Policy describes what it means to be the lead agent or the reviewer, and tells the agent what is expected in that role for each stage, and it comes with sensible presets already in place. A global set of Rules ships with the product, edit them or add your own, project Rules are entirely up to you to define, they shape how the agents work with you, your own preferences for how they respond and interact. Edit either carefully, your changes replace the defaults rather than layering on top, so a careless edit can change how a stage functions. A full reset always brings you back to the defaults.

The mental model

A workspace is a folder on disk. Everything ConflabCode knows about a project, every task, every conversation, every stage, lives under that one folder.

A workspace holds tasks, and a task is the unit of work. It remembers everything: the full conversation, the round by round history, which objectives are done, which stage it's in. Open a task, close it, come back later, and it picks up exactly where you left it.

Most work can begin as a conversation, and ConflabCode helps you preserve the useful result as structured artifacts when you decide it's ready.

Inside a task, work happens one of two ways. Loosely, in Freeform, where you just talk and things get done. Or through four named stages in order: Brainstorm, Design, Implementation, Verification.

Two agents work every task, always. Each one is either Claude Code or Codex, and depending on the stage, either one can be Lead or Reviewer. The roles swap. The agents don't.

You are the Director. That's the human in the room, and in every task, that's you. You can talk to one agent, talk to both at once, or, where the current stage supports it, let an AI Director draft and send on its own.

Whatever one agent does, the other sees it on its next turn. Not as an instruction to follow, just as context to be aware of. That's the mechanical heart of the whole tool: same conversation, not two sessions passing notes.

What to expect from agents

Before you trust anything else in this guide, it's worth being honest about what ConflabCode changes and what it doesn't.

Two agents catching each other's mistakes lowers the error rate. It doesn't zero it out. Review and Incorporate are real gates, but in Freeform they're gates you can decline to use, and even inside a structured stage, a Reviewer's approval is a judgment call, not a guarantee.

You still have to read what an agent claims it did. The tool gives you evidence, the record, the tool log, the diff, instead of asking you to take an agent's word for it. Somebody still has to look at the evidence. That somebody is you.

Structure adds dependability. It doesn't add control. If you tell an agent to do something destructive, the stage machinery doesn't stop it. The permission dialogs are what stand between you and that, and only for the operations they actually cover.

One working rule worth stating plainly. Review and Incorporate are offers, not requirements. If the work already looks right, skip Review and move on. If a Reviewer flags something not worth acting on, don't Incorporate it. The buttons make your judgment easier to act on. They are not a substitute for it.

Platforms and agents

ConflabCode is an Electron desktop app validated for routine use on Windows and macOS. Packaging artifacts may exist for other platforms, but this guide does not present Linux as a validated daily-use platform.

Two agent providers are supported and tested today: Claude Code and Codex, each through its own native runtime integration. Put the same provider in both seats, and ConflabCode warns you rather than blocking you, in case that's actually what you want.

A task needs two active provider seats to run at all. Unlike M-PACT, where a single agent is an optional, lighter weight way to work, ConflabCode isn't built around a one agent shape. Two agents is the whole idea.

Launching ConflabCode and picking a workspace

The first time you launch ConflabCode, you'll see a splash screen, then a folder picker, unless you launched with a specific path or a recent workspace already in hand, in which case ConflabCode drops you straight into it.

The folder picker gives you breadcrumbs, root shortcuts, Go Up and Home buttons, a toggle for hidden files, and a Recent row along the bottom showing your last several workspaces.

Each Recent entry shows, in parentheses, whether that workspace is already open somewhere else, and in which task, or "None" if it's open with no task picked yet. Click a Recent entry that's open in another window, and ConflabCode asks first: switch this window to it, open a brand new window, or cancel.

Opening a brand new folder as a workspace initializes it right there. The first Save Settings creates the workspace's .ConflabCode folder. Save stays disabled until ConflabCode has found both the Claude Code and Codex CLIs and an AI Helper is selected; a red note under the button lists whatever is still missing.

Provider credentials and the essentials

In Settings, Provider Credentials handles both agents. ConflabCode auto detects each agent's CLI path, with a manual override if it guesses wrong. Each provider gets its own subscription versus API key toggle, and a Launch Login button for the ones that need it.

Separately, AI Helper has its own provider, model, effort, and speed settings. This isn't a third agent you talk to. It's what powers summaries, rule checks, and a handful of other background jobs behind the scenes.

Most of the rest of Settings is routine enough that it doesn't need its own teaching space here. Part 10 covers it as a reference list.

Creating your first task

Right click the Tasks root for two options: Add Category or Add Task. Categories are optional folders. Tasks can live at the root or inside one, and you can drag them in and out later.

The Task Editor asks for a name and a description of the objective. Save commits the task without leaving the editor. Go launches the actual working view. A trash can deletes the task, and a lock icon closes it.

A brand new task defaults to Human Director, Freeform stage, free form mode, and two agent windows on your workspace's default providers. You don't have to configure anything to get moving. Name it, describe it, hit Go.

The Director panel and composer

Across the top of a task's working view sits the Director panel: your last message, an input field, a paperclip for attachments, a Human and AI Director toggle, and a counter showing how many objectives are selected versus remaining.

Enter sends your message. Shift+Enter starts a new line without sending.

Human Director means you're the one typing. AI Director means ConflabCode drafts and sends on its own. That toggle only becomes selectable when the current stage or objective is something an AI Director is actually equipped to drive. Otherwise it stays inactive, so you can't accidentally hand control to it somewhere it doesn't know what to do.

Turning conversation into durable work

Conversation creates the source material. Capture turns the useful result into durable objectives, notes, or items. Import then carries artifacts you already created into the next stage: discuss, capture, import.

There are three complementary ways to capture that work. In Freeform, click Extract Objectives; in Brainstorm, click Extract Notes. Either shortcut asks the Lead to derive artifacts from recent conversation rounds that have not already been processed. You can instead ask an agent in plain language to create or revise however many artifacts are needed, giving you conversational control over selection, scope, and granularity. Or use Add and manual editing when you want precise, direct entry.

To authorize an agent to create a durable artifact, use an explicit action word such as create, write, or build, and name the artifact you want. Discussion, suggestion, or agreement alone is intentionally not authorization to create one.

Extract is a repeatable shortcut, not a replacement for the conversation that gives it substance. Import is a different operation: it moves existing artifacts forward rather than extracting new material from the discussion. When an Import button is available, use it to carry the stage forward; it is the preferred, more thorough way to bring the complete set of existing artifacts into the next stage.

You decide when a discussion is ready to preserve. Agreement between the agents can help that judgment, but formal consensus is not required.

Targeting an agent

By default, both agents start targeted and locked. Most of the time, just say or type your message and press Enter; both agents receive it.

When you want only one agent to handle a particular message, name that agent within the first three words by agent name, provider, slot number, or role, Lead or Reviewer. A JavaScript routing helper checks those opening words before dispatch; this is deterministic routing, not an AI interpreting the message. That message routes to the named agent without changing the locked both-agents setting. You can give the agents different instructions this way without clicking either pane.

You can also change the persistent routing mechanically. Click one agent's pane to target just that agent, double-click to target both, or right-click to lock the current target so it stays set across messages. A locked, targeted agent shows a green TARGETED label with a lock icon, so you can see at a glance who's listening.

What each agent sees of the other

Whatever one agent says or does, the other sees it on its next round. Not as an instruction to follow, but as context to be aware of, clearly marked as such.

This is the mechanical difference between ConflabCode and two separate chat sessions pointed at the same code. Say something in one agent's window in a plain chat tool, and the other agent has no idea it happened unless you copy it over yourself. Here, it's automatic.

Steer and Interrupt

Outside AI Director mode, Submit queues Director Input for the selected busy agents. When any selected agent is busy, Steer becomes available as the more immediate option.

Clicking Steer opens a confirmation naming the affected agents and injects the new instruction into work already in progress. If both selected agents are busy, the dialog can steer both. If one has completed and the other is still busy, it can steer the busy agent and queue the completed one; queuing both remains available.

The red Stop or Interrupt control is the blunter option: instead of steering or queuing the round, it stops active work outright.

When an agent stalls

If an agent goes idle mid turn past a timeout, a stalled turn watchdog fires. It allows one automatic continue on its own, and if that doesn't resolve things, it asks you directly: continue, wait, or cancel. Part 12 has the fuller troubleshooting picture.

Organizing tasks

Categories are folders in the task tree. Add one by right clicking, and drag tasks in and out of them freely. Sort by number or by name.

A locked padlock icon marks a closed task. It's a soft signal, a "you probably don't need to reopen this" note to yourself, not an enforced block. Nothing stops you from reopening a locked task if you need to.

The task lifecycle

A single click opens the Task Editor. Go resumes exactly where the task left off: the full conversation, the round count, and which objectives are done, all intact.

Close Task is available from the lock control beside the focused task name and from the top-level Close Task control. Locked means closed. Clicking the locked control later reopens the task.

Closing runs a verification checkpoint, packages loose or unzipped task assets into an archive, and releases the native agent sessions behind the task.

Reopening surfaces whatever was still open when it closed, but it doesn't put any of it back into play automatically. The first thing you say after reopening should identify what's active again. Reopened tasks remain flexible: you can return to Brainstorm or another stage and add Freeform objectives, design items, implementation items, or other new work as the project evolves.

A task already open in another window shows a red, read only marker, and ConflabCode won't let you open it a second time. A different task in the same workspace, opened from another window, is fine.

Finding things again

Project Search covers the whole workspace: a cross task keyword search, a scope tree to narrow where it looks, filters by stage and by record type, whole word mode, and results grouped so you're not scrolling through a flat list.

Freeform: no ceremony required

Say "move this button seven pixels right," and the Lead just does it. No stage to pick first, no objective to write down. Review is always one click away when you want it, and never required when you don't.

The Review and Incorporate loop

When the Lead finishes a piece of work, a Review badge appears on its pane. Click it, and the Reviewer looks the work over.

If the Reviewer flags something, an Incorporate button appears on the Lead's pane. Click it, and the finding gets handed back for a fix.

After the fix, a new Review badge appears, and the cycle repeats until the Reviewer has nothing left to flag, or until you decide not to chase it any further.

Both buttons are optional, and that's deliberate. Skip Review if the work already looks right to you. Decline to Incorporate a flagged concern that isn't worth acting on. This is different from a structured stage, covered next, where review isn't something you can just skip.

Freeform Objectives

For a handful of loose objectives, the Freeform Objectives tree runs them through design, implementation, and verification automatically, with a single click.

After discussing an objective, you can click Extract Objectives, ask an agent to create the appropriate objectives, or add them manually. When asked, the agent can decide how many objectives the discussion needs, subject to your review as Director. For example: “Create as many Freeform objectives as needed to capture what we just discussed.”

It works the same way the task list does: categories, drag and drop, search hit badges. Each objective expands in place to show its full round by round history.

Archived objectives are read only, kept for reference rather than further work.

The four structured stages

Structured work moves through four stages, in order: Brainstorm, Design, Implementation, Verification.

Every stage lets you assign a Lead and a Reviewer, and you can swap those roles at each stage. Claude designing while Codex builds is one shape. Claude then reviewing the code Codex just wrote is the same two agents, one stage later, different seats.

During Brainstorm, discuss the problem first, then click Extract Notes, ask an agent to create the right number of notes, or add them manually when you want exact wording. For example: “Write as many Brainstorm notes as needed to preserve the decisions and open questions from this discussion.”

Import Brainstorm, Import Design, and Import Implementation do not extract new material from the conversation. They are the preferred, more thorough way to carry a complete stage forward: brainstorm notes become design items, accepted design becomes a sliced Implementation Plan, and completed implementation becomes a Verification Plan. Direct agent requests remain useful for creating or revising individual items.

Design cannot advance to Implementation until every design item is approved by both agents, and Verification remains unavailable until implementation completes. Control returns to Human before AI work resumes, keeping each stage transition visible and interruptible.

Provenance across stages

Design items trace back to the brainstorm notes and rounds that produced them. Implementation traces back to design. Verification checks against all of it.

At every stage, the Reviewer isn't just checking whether the agent did what it said it would do. It's checking against your original intent, with an actual link back to where that intent came from.

The more detail you give a stage going in, the sharper the result coming out. Thin notes get thin results. The structure is there to use, not a substitute for using it.

Reach Consensus

Reach Consensus launches a small automated AI Director process that has both agents compare and reconcile their positions into one agreed result you can act on.

It runs for up to ten rounds, with a Stop Consensus control if you want out before it finishes on its own. The agreed result can then become a Brainstorm note, Freeform objective, design items, or another durable work artifact.

Share Responses

Share Responses is the simpler sibling. It is one comparison pass: each agent considers the other agent's immediately preceding response, with no iterative merge. Add Director Input first when you want to frame what they should compare; leave it blank when the previous responses speak for themselves.

The baton, in plain terms

Normally, you watch context usage yourself and save your own work before you hit the wall. ConflabCode is designed to make that management largely invisible.

Each model has a context threshold expressed as a percentage. Near that threshold, the current agent prepares a curated context baton and ConflabCode pre-warms a successor. Handoff waits for a suitable pause so active work is not interrupted, then the successor continues from the baton.

Tuning the thresholds

Baton Context percent and Baton Trigger thresholds live in Settings, one per model context window.

A lower percentage suits a huge context window, where context rot and rising cost creep in well before the window is full. A higher percentage suits a smaller one, where you'd rather use more of what you have. Setting the threshold too high risks the provider's hard context limit and automatic compaction; the baton still supports continuity, but the recovery usually costs more tokens. The defaults are intended to keep this machinery out of your way.

Multiple workspaces, multiple windows

Run up to ten ConflabCode instances at once. New Window spawns a window on a workspace of your choosing, and the Recent row always shows what's open where, so you know which window points at which workspace and which task.

A per task lease stops two windows from opening the same task at the same time. A different task in the same workspace, from another window, is fine.

Opening the same workspace twice needs an explicit risk acknowledgment. Two windows editing the same task tree at once is a real conflict, not just an inconvenience, and ConflabCode wants you to know that before you do it.

Tools that fix their own mistakes

ConflabCode replaces the agents' own built in tools with its own. Normally, every mistake an agent makes costs a round trip to the provider, resending a full copy of context each time, which costs both time and money.

ConflabCode's tools catch and retry errors instead. Quoting mistakes, wrong paths, edits that need another pass, all get fixed automatically, before they ever become a round trip.

Behavior Policy

Behavior Policy describes what it means to be the Lead agent or the Reviewer, and what's expected in that role, for each stage. It ships with sensible presets already in place.

Edit carefully. Changes replace the defaults rather than layering on top of them, so a careless edit can change how a stage functions. A full reset always brings you back to the defaults.

Rules

A global set of Rules ships with the product. Project Rules are entirely yours to define, and they shape how the agents work with you specifically, your own preferences for how they respond and interact.

The same caution applies as with Behavior Policy. Edits replace, they don't layer, and the same reset is available if you need it.

The rest of Settings, briefly

The bottom center tabs

History lists every round, numbered and timestamped, with agent dots, a one line summary, and navigation back into the Director thread or a specific agent pane.

Summaries and Logs give you four scopes: Full, Selected, Up To Here, Down From Here. Summaries are AI Helper's condensed version. Logs are verbatim exports.

Journals are global, above the project and task hierarchy. Entries are not tied to one project or task, even when their content discusses either. Create as many as you need for project notes, task observations, interesting material, daily records, or anything else worth preserving; saved entries can be searched and exported.

Documents holds task result files, with Markdown and HTML export, and printing.

Results and artifacts

A result is detected automatically. An explicit artifact pointer, a flagged native write, a markdown write, or a mentioned document path all count.

Supported types are md, markdown, txt, csv, json, and html.

The Results tree mirrors the task tree, though in practice you'll reach it through Documents and the per agent artifact cards more often than through a dedicated navigation tab.

A real Freeform and AI Director run

This real task begins as a human-led product discussion, turns that discussion into two durable Freeform objectives, and then hands the selected work to the AI Director for design, implementation, and verification. Expand a round to read the original exchange; opening another round closes the one you were reading.

The progression is the useful part: rounds 1–7 turn a real conversation into reviewable objectives, round 8 hands control to the AI Director, rounds 9–11 gate and execute the work, and round 12 returns control with both objectives complete.

A three-round Reach Consensus example

This real three-round sequence starts with a diagnosis-only request, uses Reach Consensus to reconcile the findings, and then authorizes the smallest fix.

When something goes wrong