KodaArc is my own version of a Claude Code or Codex-style coding assistant, one that lives entirely in the terminal, reads and writes directly in your project directory, and runs shell commands and git on your behalf through a conversational interface. Instead of adopting someone else's black box, I wanted a tool I fully understand and can shape myself, down to which model answers a given prompt and how much autonomy it's given to actually touch the codebase.

It's still under active development. Right now, anyone can clone the repo, set up their environment variables, and run it against their own project with real model providers behind it. What I'm chasing next isn't stability, it's the one or two features that would make it genuinely more useful than the tools it's inspired by, rather than a well-built copy of them.

The Problem

I didn't build this because Claude Code or Codex don't work. I built it because I wanted to actually understand how a tool like that is put together: how you let a model read a codebase, decide what to change, and make that change safely, without either being too cautious to be useful or too autonomous to trust. Using someone else's assistant teaches you what it's like to be a user of one. Building your own teaches you what's actually happening every time it decides to run a command instead of just answering a question.

I also wanted control that off-the-shelf tools don't give you: the choice of model per session, per-provider options like extended thinking or reasoning effort, and a way to draw a hard line between "just look and propose" and "go ahead and change things," instead of trusting a single mode to always guess which one I want.

Key Features

Dual-mode agent. Switch between PLAN mode, read-only analysis and proposals, and BUILD mode, full read/write/execute, on the fly, so the assistant never touches your files unless you've explicitly told it it's allowed to.
Multi-provider model support. Anthropic, OpenAI, and Google models are all available from the same interface, with per-model provider options like extended thinking and reasoning effort exposed directly.
Eight sandboxed tools. readFile, writeFile, editFile, listDirectory, glob, grep, bash, and a gitHelper, all scoped to the project directory the assistant is running in.
Real-time streaming in the terminal. Reasoning deltas, text deltas, tool calls, and tool results all stream live over SSE and render directly in the TUI as they happen, not after the fact.
Persistent sessions. Every conversation, including message history, individual parts, durations, and interrupt states, is saved to PostgreSQL, so nothing is lost between runs.
A command palette and themeable interface. Slash-commands like /models, /agents, /theme, and /sessions for quick control, with multiple color themes and spinner styles saved to your local preferences.

Under the Hood

KodaArc is a Bun monorepo split into four packages, each with a single job:

cli is the actual terminal UI, built with React 19 on OpenTUI, handling screens, hooks, providers, and theming.
server is a Hono HTTP API that owns AI streaming, tool execution, and session CRUD, the actual brain of the operation.
database wraps Prisma 7 and PostgreSQL for the schema, client, and shared enum exports.
shared holds the Zod schemas, model registry, and TypeScript types every other package depends on.

The server is where the real complexity lives: it has to route a request to the right provider, stream partial responses back to the terminal in real time, decide when a tool call is warranted, execute that tool safely inside the sandboxed project directory, and feed the result back into the conversation, all while keeping the whole thing resumable and persisted.

The Hardest Part

Tool calling was, by a wide margin, the hardest thing to get right. Models would hallucinate tools that didn't exist, call the right tool with the wrong arguments, or confidently pick the wrong tool entirely for what the user actually asked. Getting a model to reliably decide when to read a file versus grep for a pattern versus just answer in plain text, and to do it consistently across three different providers with three different tool-calling conventions, ended up being the single biggest source of bugs and the thing I spent the most time iterating on.

Where It's Headed

The core loop already works: clone it, add your API keys, and it runs against real Anthropic, OpenAI, or Google models with full tool access to your project. The open question now isn't "does it work", it's what would make it worth reaching for over Claude Code or Codex specifically. That's the feature I'm currently hunting for.