CodeInOven

Open source · MIT licensed

Your agents already write the code.
Somebody has to run the kitchen.

CodeInOven is the desktop control plane that sits above your coding agents — six harnesses, one reviewable lifecycle, one auditable record. Bring your own subscription. Fork the whole thing.

Download for macOS Windows · Linux

Drives the agents you already have installed

  • OpenCode
  • Codex CLI
  • Claude Code
  • Pi
  • Cline
  • Antigravity
The CodeInOven workspace: a project and thread rail on the left, an agent run in the middle showing reasoning traces and tool calls with status, and a context panel on the right.
The actual application. Threads on the left, the run in the middle, assembled context on the right.

The matrix

Bring your own harness. All of them, if you like.

Most tools marry you to one agent. CodeInOven detects what is already installed on your machine and drives it through the same typed contract — so the choice of engine stops being an architectural commitment and becomes a dropdown.

Or point it at your own metal

Any OpenAI-compatible endpoint works. These three are one-click presets — everything else is a base URL and a model id.

  • Ollama http://localhost:11434/v1
  • LM Studio http://localhost:1234/v1
  • llama.cpp http://localhost:8080/v1

Or the hosted ones you already pay for

Sign in through the harness's own account, or bring a key. Credentials stay in the harness's config where they belong — CodeInOven does not proxy your traffic.

  • openai
  • anthropic
  • google
  • xai
  • deepseek
  • qwen
  • mistral
  • groq
  • openrouter
  • huggingface

The lifecycle

Four stages. No silent jumps between them.

A chat window hides the moment a suggestion becomes a change. CodeInOven makes that moment a stage you have to walk through.

  1. Specify

    Write the engineering specification, not a prompt.

    Specs stay editable through inline and section annotations. Context is assembled explicitly — system, project, skills, MCPs, checklist, history — so you can see what the agent will be told before it is told.

    systemprojectskillsMCPschecklisthistory

  2. Review

    The human reviews. The agent implements.

    Plans surface in the same thread as the work, with visible state transitions and a real approval gate. Nothing moves to implementation because a model felt confident about it.

    plan diffstate transitionsapprovesend back

  3. Approve

    Permission is a policy, not a vibe.

    Two levels, always on screen. Auto Review runs anything you have not explicitly denied. Full Access is the deliberate, clearly marked exception — the app calls it what it is rather than hiding it behind a friendly toggle.

    Auto ReviewFull Access

  4. Implement

    Runs you can replay, diff and roll back.

    Implementation executes against the approved spec with independent audit and rework cycles. Atomic writes, chunked history, checkpoints and per-thread branches mean any session can be reconstructed later.

    checkpointauditreworkdiff
A CodeInOven run in progress: collapsible thinking blocks with durations, and tool call rows showing shell commands and file reads with success, failure and running status.
Reasoning, tool calls, durations and exit status — inline, and still there tomorrow.

The workstation

Built like an instrument, not a landing page

One workflow, six harnesses

OpenCode, Codex, Claude Code, Pi, Cline and Antigravity all plug in behind a single typed driver contract. Swap the engine mid-project; the threads, specs and history stay exactly where they were.

Chunked, atomic history

Every write lands as a temp file and a rename. History is chunked and capped, pinned threads survive cleanup, and no session ends up half-written because something crashed.

Per-thread branches

Threads carry their own branch and change set. Review the diff, commit or compare from the context panel without leaving the run you are watching.

Scope you can see

The permission level for the current thread sits in the composer, beside the model and the thinking level. You know what the agent may do before you press send.

A real terminal, attached

A PTY-backed terminal lives beside the conversation, so the commands an agent runs and the commands you run share one machine and one working tree.

Thinking you can read

Reasoning traces, tool calls, durations and exit status render inline and stay in the record. When a run goes wrong you scroll up instead of guessing.

The CodeInOven composer, showing the current permission level set to Full Access, the selected model, a Medium thinking level, and a stop control while the agent works.
Permission level, model and thinking level sit in the composer — visible before you send, not after.

Principles

The rules the product holds itself to

Determinism over vibes

If a run cannot be replayed from persisted state, that is a bug — not a quirk of working with models.

The human reviews

The agent implements by default, but approval is a gate in the lifecycle, not a courtesy notification after the fact.

Never touch what is not yours

CodeInOven keeps its own state in its own config directory. It does not write uninvited into your repository.

Bounded on purpose

Threads, history chunks and checkpoints are all capped. Growth is a decision you make, never something that happens to you.

Your agents. Your models. Your machine.

CodeInOven runs on your desktop, drives the harnesses you already have installed, and keeps every run reviewable long after the conversation scrolls away.

Download CodeInOven Read the source