Codiak

Verified delivery of AI-written changes

Tickets in. Verified changes out.

Codiak hands your tickets to coding agents and merges nothing on trust. A contract of failing tests comes first, your project's checks and an independent review decide, and every ticket carries its measured cost.

How it worksEarly access
CodiakTicketsJira, Azure, …Repositorygit, svn, …AI providerClaude, GPT, …Codiak masterProject specificskills, agents, secrets, …Codiak proxyall traffic, mandate rightsMonitoringhealth, cost, alertsDispatcherqueue, balancingplugin busCodiak worker node 2n jobs in parallelCodiak worker node Nn jobs in parallelCodiak worker node 1mandate contextContractfailing tests firstImplementthe agent worksGatesyour checks runReviewindependentMergeonly if greenRetrospectivewhat we learnedfinding
Click any part to see what it does

How it works

Every ticket takes the same path, on as many worker nodes and in as many parallel jobs as you run.

  1. A ticket arrives

    Your tracker is a plugin (Jira, Azure DevOps, …). A ticket that says what to build and which files it touches joins the queue in priority order.

  2. A contract first

    Before any code is written, tests that define what “done” means are committed, and they fail. The agent works until they pass and cannot change the goal.

  3. Gates decide

    Your project's checks (typecheck, lint, coverage, mutation testing) and an independent review. Only a green delivery merges; a red one returns with the exact finding.

  4. Cost and lessons

    Every run ends with a retrospective. Its measured cost and what it learned are recorded and fed back, so the next job starts better informed.

Everything is a plugin

The core is small on purpose: it orchestrates. What runs in the nodes, and how, is modular. Bring anything you want.

The core

  • Master and worker nodesA Kubernetes-like shape, without Kubernetes. A master queues the work; nodes pull it and run every job in its own container.
  • A proxy for rightsEach job gets a mandate. It reaches trackers, repositories and models only through the proxy, within the rights and cost limits that mandate names.
  • A mirror into monitoringModel calls, tokens and cost are mirrored into monitoring, so what a job did is always on the record.

Plugins: the rest

  • TrackersJira and others
  • Code hostsgit hosting
  • AI providersClaude and others
  • Executorsisolated containers
  • Checks and gatesyour project’s own
  • Pipeline and reviewthe ticket flow above
  • Knowledge and viewssearchable project knowledge

A plugin states its contract and passes that contract’s tests, so swapping Jira for another tracker means swapping one plugin. The master’s configuration names the plugins in use, and the nodes mirror it.

Default plugins

What comes with Codiak. Swap any of them or add your own.

Manage

Operate Codiak, your way.

  • CLIA Kubernetes-style command line. Everything goes through the API.
  • Web UIA graphical front end to the same API: whatever the UI can do, the CLI can do too.
  • MCPLets your own agents operate Codiak through that same API.

Connect

Reach the systems you already use.

  • JiraTickets in; comments, links and transitions out.
  • GitBranches and merges, guarded by what the repository server enforces.
  • AI proxyModel access with the limits of each job’s mandate.

Run

Do the work, in parallel and isolated.

  • Ticket pipelineContract, implement, gates, review, merge, retrospective.
  • DispatcherPriority queue, balancing over the nodes, a mandate per job.
  • Container executorEvery job in its own isolated container on a worker node.
  • ScheduleRecurring jobs without anyone starting them.

Oversee

Keep it honest and on the record.

  • RolesWorker and manager charters, enforced mechanically, not by prompt.
  • OversightReads the state regularly and reports anomalies with their evidence.

Features

  • Contract before code

    The first commit is a set of failing tests with named use cases. Implementation starts after that contract is reviewed, so what done means is settled before any code is written.

  • Gates, not trust

    A delivery is measured in a fresh container against your project's own requirements. A failure returns to the agent with the exact lines, not a vague try again.

  • Cost and outcome, measured

    Every run records its tokens, time and cost; every ticket records its rounds and how it ended. You can ask what a merged ticket cost and where the money went.

  • Budgets that hold

    A daily budget and a per-ticket envelope stop spending that outruns the value. When a ticket has used its rounds it stops and asks a person instead of looping.

  • Plugins at every edge

    Tracker, git, checks, model roles and views are plugins with written contracts. The core assumes nothing about your tracker or language, so a new system is a new plugin.

  • Workers you can place

    Work runs on separate worker nodes that ask the master for jobs and report back, each job in its own container. A node is a machine with Docker.

Where it runs

Early access is arranged case by case. We start with the set-up that fits your constraints.

Set-upWho runs whatStatus
ManagedWe run the master and the workers.planned
Your workersWe run the master; you run workers next to your code and use your own AI provider (BYOK).planned
Self-runYou run all of it.in active development

Early access

Bring a repository

A repository with tests and a tracker board. We start with one narrow kind of ticket.

We run it and report

On your tickets we measure what matters: how many pass first time, how often a person must step in, and what a merged ticket costs.

Then you decide

With those numbers in hand you decide whether it earns a place. No commitment before that.

Get in touch