Apache Maka

Apache Maka (Incubating) is a desktop, TUI, and CLI agent workspace built around a single idea: the log is the runtime. Every model message, tool call, permission decision, and termination fact is written as an append-only RuntimeEvent, and everything else in the product — the chat UI, the next prompt sent to the model, crash recovery, session resumption — is a projection of that log rather than a second copy of the truth. That makes a Maka session auditable and recoverable in a way ad-hoc agent scripts are not: you can inspect exactly what happened in a run after the fact, and a crashed session can be reconstructed from its event history.

The project ships three thin clients over one execution authority, the Runtime Host: an Electron desktop app, a terminal UI, and a non-interactive CLI (maka run). All three go through the same SessionManager and AgentRun machinery, so a task started in one surface behaves identically in another, and a State Root has exactly one Runtime Host as its write authority. On top of single-agent runs, Maka has an Agent Graph control plane for multi-agent orchestration — maka run --graph schedules dependent child sessions, each operating in an isolated Git worktree, and reconciles their output back through the same event log.

A separate @maka/eval package turns the same Runtime Host into a benchmarking substrate: experiments expand into cells (task × repetition × subject), each cell runs as one or more immutable attempts, and results are scored with a declared verifier rather than an operator’s preferred outcome. The project publishes its own harness benchmarked against competitors on the same model with the same verifier, with per-task results checked into docs/eval/.

Maka is Apache-2.0 licensed and openly building toward its first ASF release; nightly desktop builds are available for macOS, Windows, and Linux today. It does not bundle a model account — you bring your own API key, local model, or supported provider connection, and all session, settings, and run data stay local to your machine (SQLite plus a local plaintext credential file, never sent to a Maka-operated server).

What You Get

• A Runtime Host that owns session identity, agent lifecycle, tool permissions, and event history as the single execution authority for a given State Root
• Three interchangeable clients — Electron desktop app, terminal UI, and a scriptable CLI (maka run) — that all drive the same underlying Runtime rather than reimplementing agent logic per surface
• An Agent Graph control plane for multi-agent work: maka run --graph schedules dependent child sessions, each in its own isolated Git worktree, and reconciles results back through the shared event log
• A built-in evaluation framework (@maka/eval) that runs benchmark experiments as declarative cells and attempts, with a fixed verifier and no operator override of which result counts
• Local-first data ownership: sessions, settings, and credentials live in a local SQLite store and a local credential file under your OS account, with no required cloud account
• Bring-your-own-model support for cloud APIs, local models, or compatible gateways, with connection states that distinguish configured, send-ready, and experimental setups

Common Use Cases

• Running autonomous coding tasks from the terminal (maka run "...") and reviewing exactly which commands and edits the agent made from the event log afterward
• Multi-step feature work split into independent slices via Agent Graph, where child agents work in separate Git worktrees and get integrated and reviewed automatically
• Benchmarking a new agent harness or prompting strategy against a published, verifier-scored evaluation suite instead of ad-hoc manual comparison
• Running agent sessions fully locally against a self-hosted or local model, for teams that don’t want session transcripts leaving their machine
• Recovering an interrupted long-running agent task from its durable event log rather than restarting the task from scratch

Under The Hood

Architecture Maka is organized as a layered monorepo with the Runtime Host as the sole write authority for a given State Root: packages/core defines pure Session, RuntimeEvent, AgentRun, and permission contracts; packages/storage implements the SQLite-backed operational stores; packages/runtime holds SessionManager, AgentRun, model adapters, tools, and context/recovery logic (over 240 test files alone); and packages/runtime-host exposes the single hosted execution boundary and public client protocol that Desktop, the TUI/CLI, and @maka/eval all call into. Multi-agent scheduling sits in an Agent Graph control plane (agent-graph-control.ts, agent-graph-schedule.ts, agent-graph-supervisor-wake.ts) that dispatches child Sessions into isolated Git worktrees and reconciles their activations back through the same Runtime Event Log — the log itself, not the chat transcript, is the canonical record that context pruning, compaction, and the UI all project from. apps/desktop is a thin Electron composition layer (main/preload/renderer) over this shared backend rather than a place where agent logic lives.

Tech Stack The codebase is almost entirely TypeScript (roughly 92% of source) with a small Rust footprint (native/runtime-host-peer, native/gitoxide-helper) built with Cargo for a direct peer-to-peer networking addon and a Git helper, plus a Python slice supporting Windows tooling. It’s an npm workspaces monorepo (Node 22.19+, npm 11) with dedicated packages for storage, MCP client integration (packages/mcp), computer-use backend selection (packages/computer-use), and a CLI/TUI package, alongside an Astro-based marketing site (website/). Electron drives the desktop shell, Biome handles linting and formatting, Husky enforces pre-commit checks, and model metadata is synced from models.dev with a script that fails closed on any unexpected removal of a committed model or pricing field.

Code Quality The project is unusually rigorous for its age: tsconfig.base.json enables full TypeScript strict mode across every workspace, and the repository runs 30+ dedicated GitHub Actions workflows covering CI, nightly desktop builds, dependency auditing, ASF release candidate checks, and platform-specific release verification. Tests live alongside source in __tests__ directories per package (the runtime package alone has 240+ test files) and are run per-workspace via a custom parallel test runner (scripts/run-workspace-tests-parallel.mjs), with knip configured to catch unused exports and dead code. Contribution requires typecheck, build, and proportionate focused tests before submission, and the project keeps a .git-blame-ignore-revs file, suggesting active discipline around large mechanical diffs staying out of blame history.

What Makes It Unique Most agent tools treat the chat transcript as the primary state and everything else — resumability, auditability, multi-client support — as an afterthought bolted on top. Maka inverts that: the RuntimeEvent log is defined as the canonical source of truth, and the UI, the next-turn prompt, and crash recovery are explicitly documented as projections of it, which is what lets old tool output leave the model’s context window without leaving the permanent record. Combining that log-as-runtime model with a single enforced execution authority per State Root (so Desktop, TUI, CLI, and eval clients can’t diverge into separate agent implementations) and a first-class evaluation framework that ships its own published, verifier-scored benchmark results is a distinctive combination not found together in comparable open-source coding-agent projects.

Self-Hosting

Licensing Model Apache-2.0 licensed — the full Runtime Host, Desktop app, TUI, CLI, and evaluation framework are open source with no license keys or feature gates found in the codebase.

Self-Hosting Restrictions None identified. No ee/, enterprise/, pro/, or cloud/ directories exist in the repository, and no license-check or feature-flag gating code was found.

Enterprise Features Not applicable — there is no separate paid tier. Maka does not bundle a shared model account; users bring their own API key, local model, or supported provider connection.

Cloud vs Self-Hosted Maka has no hosted cloud offering. All session, settings, and credential data is stored locally under the OS user account by design.

License Key Required No.