Not a plug-in — a platform. Everything an agent touches becomes an artifact: inspectable, citable, reusable.
writing stripe-usage.ts
41/58 integration passing
verifying checkout flow in live DOM
Big files and tool outputs live on disk. The model cites them on demand — context stays lean, runs finish.
/Projects plus a knowledge graph. Every run starts with everything the last one learned.
Specialised agents spawn mid-run with context distributed between them — not duplicated.
Everything is a command: switch actions, continue runs, rewind files, set roles and modes. And every run ends the same way — a completion report you can audit.
> /help /new Start new conversation /status Show current action & run /use <action_id> Switch to a different action /continue <run> Continue an existing run /upload <path> Attach files to next message /rewind Rewind files to a previous state /role <role> Set role (auto sets mode=build) /mode <mode> Set current mode /runs list List recent runs /theme set <name> Set & persist theme /show-logs Local CLI runtime logs
> list all files in the cwd, clean up scrap, organise the directory ● All clean now. Completion report: ✅ Cleanup Complete — Completion Report Changes Made • Moved ~50 Screenshot*.png → screenshots/ (now 131) • Deleted junk: C.txt, .vim_swap/ • aks.txt → documents/relativity_notes.txt • fighting-game.html + README → projects/fighting-game/ • Created .kiwi/ docs: CODEBASE_SIMPLIFIED.md, decisions.md Final Structure Desktop/ ├ documents/ ├ projects/ ├ scripts/ ├ screenshots/ (131) └ .kiwi/ (4 metadata files) Assumptions .DS_Store left in place · scripts/ kept — server code
Agent narrative is untrusted input. Every run ends in a handoff — branch, SHA, PR — reconciled against the worktree, not the model’s word.
What changed, where it landed, what was explicitly not done.
HEAD, dirty state, PR status — read mechanically. Agents never grade their own homework.
Stated confidence vs. how that band actually held up. Recomputed from merge outcomes, not vibes.
Artifacts-first context, 100+ connectors, full database CRUD.
/Projects holds your architecture and decisions. Any agent picks it up instantly.
Finds bugs in the live DOM, fixes them, re-verifies — then hands back.
Self-healing calls survive schema drift. Zero creds in prompts, ever.
An artifacts-first agentic coding platform. Files, tool outputs, and long sessions are stored as artifacts instead of tokens — context stays lean, long runs finish, and costs drop up to 90% versus token-heavy approaches.
Most coding agents demo the first 70% of a task. Kiwi Code is built for the last 30% — long runs, real integrations, and work you can verify: every run ends in a handoff with branch, commit SHA, and PR, reconciled against the git worktree.
Individuals: $100/month, unlimited usage — Kiwi’s default model included, or bring your own keys. Teams get the code factory — work orders, gates, shared memory, decision traces, RBAC and SSO — on a custom plan.
Agent claims are treated as untrusted input. Kiwi Code reads HEAD, dirty state, and PR status directly from the repository and reconciles them against what the agent reported — agents never grade their own homework.
Yes — both ways work on the same $100/month plan. Kiwi’s default model is included, no extra cost. Prefer your own? Add your API keys for OpenAI, Anthropic, or any supported provider and Kiwi Code routes your runs through them under your own agreement.
Credentials never enter model context (server-side OAuth), memory is RBAC-scoped, execution runs in disposable sandboxes, and agents start read-only — authority is earned one rung at a time.
Kiwi Code is onboarding enterprise teams now.
› Contact Us