Kotta

The last 10% is the whole job. Start there.

AI made the first 90% cheap. Kotta holds the rest as a contract in your repo: acceptance traced to specification, checks that run instead of being narrated, and a human yes — with a receipt — before anything closes.

Install Kotta View on GitHub

Local-first · MIT licensed · plain files · no hosted account

Start in any Git repository npm install --global @arpadtamasi/kotta Full setup ↓

AI can execute more work than you can continuously observe.

The bottleneck moved. It is no longer producing code. It is keeping the agreement intact while agents move faster than the conversation around them.

Chat forgets the promise.Intent dissolves into scrollback, follow-ups, and a different session tomorrow.
Agents report “done.”The claim arrives before reproducible evidence and human acceptance.
Parallel work shares risk.Branches, claims, dependencies, and decisions become coordination by memory.

Three ways in.

The specification says what must be true. The code is the implementation. A task connects them — and it cannot close until a human accepts the evidence. Three entries into the same loop.

  1. New software

    spec → task → code

    You have an idea, not a specification, and you are not going to write one in Word. The workshops run as conversation and land nodes an agent can execute against the same hour.

  2. A legacy rewrite

    code → spec → task → code

    The code is the only specification you have, and it will not say which behaviour was ever intended. Read it back out, and the rewrite finally has something to be wrong against.

  3. A codebase already under way

    running system → observation → spec → task → code

    Nobody stops the world to specify it first. What the running system tells you becomes an observation, dispositioned on purpose, never folded into the task you are on.

The agreement becomes executable.

Kotta keeps the promise, the run, and the proof in the repository. Your agent gets a bounded task. You get the final decision.

  1. 01

    Define

    Write the outcome, scope, acceptance, and verification.

    backlog → defined
  2. 02

    Execute

    Claim one task on one branch in one isolated worktree.

    defined → active
  3. 03

    Prove

    Map each acceptance condition to concrete, reproducible evidence.

    active → review
  4. 04

    Accept

    A human says yes. Kotta records who approved what and when.

    review → done
.kotta/spec/what must be true .kotta/process/what is happening git historywhat actually happened

Not another agent. The control layer around all of them.

Keep the tools you already use. Kotta gives their work one durable agreement and one legal path to completion.

LayerWhat it keepsWhat it controlsWhat “done” means
Agent chatThe conversationThe current runThe agent says so
Issue trackerThe human-readable issueStatus and ownershipTeam convention
Agent runtimePrompt and execution contextTools and modelRuntime-specific checks
Spec generatorThe spec filesNothing after handoffThe plan was written
KottaThe accepted repository agreementClaims, Git isolation, gatesEvidence accepted by a human

Install it. Define one real task.

Kotta runs inside the repository you already have. Node.js 20+ and Git are the only runtime requirements.

  • No service to deploy
  • No database to maintain
  • No account to create
  • No hidden state to trust
terminalverified setup
# Install the CLI
npm install --global @arpadtamasi/kotta@0.10.0

# Inside an existing Git repository:
# workspace, agent skills and the rules your agents read
kotta init

# Or drive it from the chat
/setup-kotta
/define-task
Created task T-… Waiting for your approval.