AI coding
with receipts.
k-lani-coder turns AI coding into a measured workflow: owner idea -> planner contract -> scoped worker -> reviewer -> WORM receipt. The worker receives the ticket, allowed symbols, relevant slices and the gate - not a repo dump. When calls are routed through the API proxy, tokens and costs are recorded per ticket, role and phase. Subscription agents are supported too, but their cost row is flat-rate evidence, not provider billing.
Unpriced
AI coding
Whole-repo agents are convenient. For an empty project or a tiny isolated change, they may even be the cheapest path. The failure mode starts in existing products: the model searches broadly, burns tokens on discovery, edits outside the intended scope, and leaves a transcript where an engineering receipt should be.
Then the business questions become hard: Which role spent the tokens? What did the worker actually see? Which files changed? Which tests justified acceptance? Would a direct agent, an API worker, or a flat-rate subscription worker have been cheaper?
k-lani-coder is the control plane for that decision. It does not promise that orchestration always wins. It makes the trade visible and lets you switch: direct agent for small self-contained work, scoped planner/worker/reviewer flow for changes where context, audit, impact and cost attribution matter.
Four stages,
each independently verifiable
Plan
A backlog idea becomes a contract: level, tags, allowed symbols, model and effort, classification, done criteria and gate. The planner's job is not to write code. It decides what the worker needs and what the worker must prove.
Slice
The symbol index and codemap assemble the smallest useful context package: target code, direct dependencies, signatures, docs and an honest omitted list. If a task needs more room, the profile can widen or disable guardrails explicitly instead of pretending one rule fits all.
Meter
API-key runs through the k-lani proxy produce exact input, cached, output, reasoning and price rows per ticket, role and phase. Codex and Claude Code subscription wrappers are labelled flat-rate: useful operational evidence, not exact provider-billed cost.
Gate
Writes are ticket-scoped, diffed and reviewed behind guards: scope, policy, formatting and the only acceptance authority that matters, your project's own compiler and test suite. The model's opinion of its work is irrelevant; the gate verdict is recorded.
A sprint is
not a meeting.
It is data.
On top of the loop sits a ticket board persisted in the same append-only engine. The owner fills the backlog; advisors can challenge the request; the planner turns it into a machine-checkable contract; workers run only the selected slice; reviewers judge the diff, tests and evidence. No agent can approve its own work - enforced in code, not in prompts. Every transition is one immutable ledger row, and board-web shows it live. When a ticket lands, its receipt is one click away: asked, contracted, built by whom, changed files, attempts, gate verdict, and measured or flat-rate cost evidence.
open · 2
claimed · 1
done · 2
What one ticket really cost — per phase, from the ledger
| phase | route | model | evidence | cost |
|---|---|---|---|---|
| planner | /planner/v1 | gpt-5.5-high API | provider tokens | exact USD |
| worker | codex docker | gpt-5.5-medium subscription | wrapper tokens | flat-rate |
| review | /review/v1 | gpt-5.5-medium API | provider tokens | exact USD |
| ticket total | split by role | no mixing | ||
The board separates exact API costs from flat-rate subscription evidence. If a run is not measurable, it is labelled that way instead of being silently treated as zero.
Use the right
execution mode
k-lani-coder is not a slogan that says "always cheaper". It is the system that lets you prove which mode was cheaper, safer, or more controllable for the work in front of you.
| Situation | Direct agent | k-lani-coder |
|---|---|---|
| Small greenfield task | Often cheaper: one capable agent can build end-to-end. | Use only if you need receipts, role separation or repeatable gates. |
| Existing product change | Can spend heavily on broad discovery and accidental context. | Planner selects scope; worker sees only the contract and slices. |
| API-key benchmark | Exact if routed through the proxy. | Exact by ticket, role and phase when API-routed. |
| Subscription benchmark | Operationally useful, but provider cost is flat-rate and not per-call. | Recorded honestly as wrapper tokens plus API-equivalent estimate. |
| Audit and review | Transcript and git diff must be interpreted manually. | WORM receipt: plan, claim, diff, gate, review, release and cost evidence. |
| Local or open models | Usually external to the native agent surface. | Optional worker tier, not the premise. High-quality API models remain the default path. |
Explicit outbound.
Auditable evidence.
- ✓Explicit outbound boundary. The harness itself has no telemetry, update check or license callback. Cloud traffic is either the configured API proxy or the official subscription agent you intentionally launch.
- ✓Key custody when API-routed. Upstream credentials live in the proxy; agents get a dummy. Subscription agents use their official login/session and are labelled as such in the evidence.
- ✓Measurement honesty. API rows are exact provider-token and price rows. Subscription rows are flat-rate wrapper evidence. Missing measurements stay visible instead of being counted as zero.
- ✓Immutable evidence. Ideas, refinements, tool calls, board transitions, refused writes, diffs, gates and cost rows become append-only WORM ledger entries. The audit trail is the same data the system runs on.
- ✓Classification & residency. Tickets carry a sensitivity grade, deployments a jurisdiction. A secret ticket cannot even be seen by a model hosted in the wrong place - enforced in code at claim time, deny by default.
- ✓Honest evaluation builds. Binaries declare their expiry in --version. After the date, operational commands stop — every read path works forever. Your data is never hostage.
Stop guessing
what AI coding cost.
Plan the task, scope the worker, meter the route, review the diff and keep the receipt. Use direct agents when they are enough; use k-lani-coder when the codebase, budget, customer promise or audit trail makes uncontrolled context too expensive.