Apache Maka: A Local-First Agent Runtime That Keeps the Record

What Maka Solves and Who It Is For

Maka addresses a specific pain: AI assistants that lose track of what they did. Most agent tools treat the conversation as a transient stream, and once the context window fills, earlier tool output is gone. Maka's core promise is that the record is kept. Every model message, tool call, permission decision and termination is an append-only RuntimeEvent. The UI and the next model call are views of that record, not the only copy. This is aimed at engineers who run agents on real projects and need to audit what happened, recover from a crash, or resume an interrupted turn. The target user is a developer on an Apple Silicon Mac who wants the agent to run locally, with their own model connection, and who values reproducibility over convenience. The repository description states that the macOS Apple Silicon desktop build is an early public release, and data formats and CLI commands may change. So this is for early adopters, not for production teams that need stability.

The Runtime Host: One Place Runs the Agent

The architecture is built around a single component called Runtime Host. Desktop, the terminal, and Maka evaluation all go through this runtime. That means the same execution engine powers the graphical interface, the command-line tool, and benchmark experiments. The README says that eval only owns the experiment and its scores; the actual agent execution is delegated to Runtime Host. This is a deliberate design choice that keeps behavior consistent across surfaces. If you run a turn in the desktop app, then run the same command via the CLI, you go through the same execution authority and the same record format. The trade-off is that the runtime becomes a central dependency. If it fails, every surface fails. But the benefit is that a bug fixed in the runtime is fixed everywhere. The README also lists crash recovery as a projection of the log, which is only possible because the execution record is durable and not tied to a live UI session.

How the Execution Record Works

The key mechanism is the durable execution record. Every model message, tool call, permission decision and termination is an append-only RuntimeEvent. The UI and the next model call are both derived from that record. The record also enables a feature that the README highlights: shorter context is not deleted history. Maka can omit old tool output from the next prompt without throwing away the saved evidence. That is a practical solution to the context window problem. Instead of truncating the conversation and losing the details, Maka keeps the full record but only feeds a summarized or pruned version to the model. This is a meaningful difference from tools that simply drop old messages. The record is also what makes crash recovery possible. If the process dies mid-turn, the runtime can pick up from the last recorded state.

Getting It Running: Build from Source, No Prebuilt Downloads

The README says the latest Apache release is 0.2.2 (incubating). The signed source archive is the official release; packages distributed elsewhere are convenience artifacts, and development builds are not approved Apache releases. Either way, Desktop is built from source. The requirements are Node.js 22.19 or newer on the 22 line or Node.js 24 or newer (Node.js 23 is not supported), npm (the packageManager is npm 11), GnuPG to verify a release archive or Git for contributor development, and ripgrep, which the Runtime's Grep tool uses. The quick start is straightforward: clone the repository, run npm ci, then npm run dev. That starts the Desktop development environment with HMR. If you want to build every workspace before starting Electron, use npm run dev:full. There are also peer-enabled entry points for Direct Peer and Peer Mesh development, which require Rust stable 1.98 or newer and the platform linker. Those are npm run dev:peer for HMR and npm run dev:full:peer for a full build. If you installed dependencies with ELECTRON_SKIP_BINARY_DOWNLOAD=1, you need to install the Electron platform binary first. From a source checkout, npm run build and then npm run cli:dev starts the TUI, and npm run cli:dev -- run "<task>" runs one Turn. The setup is not trivial. You need a recent Node.js, ripgrep, and possibly Rust if you want peer features. That is a higher barrier than downloading an installer, and the official Apache release is itself a signed source archive.

Sandbox Boundaries and Tool Approval

The README records every permission decision as an append-only RuntimeEvent alongside model messages, tool calls and terminations, and it names a Grep tool in Runtime that relies on ripgrep. It does not lay out the permission rules in its opening sections, so read ARCHITECTURE.md, which the README calls the system map, before trusting the tool boundary with sensitive work.

Evaluation: Reproducible Benchmarks with a Small Result Kernel

Eval is a separate surface, but it does not run agents itself. The README says Desktop, the TUI and CLI, and Eval are thin clients of one Runtime Host, and that Eval owns only the experiment and its scores. The architecture diagram shows the eval chain as Experiment → Cells → Attempts → Results, with Runtime Host executing Maka subjects. The project frames this as "measured, not claimed": Maka is benchmarked against other harnesses on the same model with the official verifier, and the per-task results ship with every report in docs/eval/. Evaluation specs and adapters live in packages/eval, which is where to look before writing your own spec.

Limitations and Wrong Use Cases

The most obvious limitation is platform support. The repository description names the macOS Apple Silicon desktop build as the early public release. Another limitation is the early release status. The README warns that data formats, CLI commands, and experimental capabilities may change. That means anything you build on top of Maka today could break with the next version. The official Apache release is a signed source archive, and packages distributed elsewhere are only convenience artifacts. Building from source requires Node.js, npm, ripgrep, and possibly Rust. That is a significant setup cost. Finally, the project is incubating at Apache, which is a process that may take years. The repository also ships a DISCLAIMER-WIP file, which is worth reading before adoption.

Alternatives and How They Differ

A common alternative is a cloud-based agent like OpenAI Codex or GitHub Copilot Workspace. Those run on remote servers and keep your conversation history in the cloud. Maka is local-first, meaning sessions, settings, and run records stay on your machine by default. That is a fundamental difference in data ownership. Another alternative is an open-source local agent like Continue or Aider. Maka's record is at the level of tool calls and model messages. Maka's Runtime Host and eval surface are more comparable to a framework like LangChain or LlamaIndex, but those are libraries, not standalone applications. Maka is a full workspace with a UI, CLI, and eval tool. Maka's focus on a durable, recoverable execution record is its distinguishing feature.

Maintenance and License Implications

Maka is licensed under Apache-2.0, which is a permissive license. That means you can use, modify, and distribute the code, even in proprietary products, as long as you include the license notice. There are no copyleft obligations. That is a low-license-friction option for commercial use. However, the project is incubating at Apache, which means it is not yet fully endorsed by the ASF. The project is under active development, with recent nightly builds like v0.2.2-dev.106.20261030. The last push was on 2026-11-02, which suggests regular activity. But the maintenance cost is on you. Because the desktop build is an early public release, you must track changes to data formats and CLI commands. Upgrading could require migration of your existing session records or adjustments to your scripts. You should plan for breaking changes. The dependency on ripgrep is a system-level requirement that you must maintain. The Rust requirement for peer features adds another toolchain to manage. Overall, the maintenance cost is moderate but requires vigilance.

Editorial conclusion

Adopt Maka if you are a developer on Apple Silicon who wants a local-first agent runtime with a durable execution record and is comfortable building from source and tolerating early-stage instability. Do not adopt it if you need stable data formats and CLI commands. Before adopting, verify the current state of the DISCLAIMER-WIP file, check whether the data formats and CLI commands have stabilized, and confirm that the Apache Incubation status does not block your use case. The latest Apache release is 0.2.2 (incubating) and ships as a signed source archive; packages distributed elsewhere are convenience artifacts.

Frequently asked questions

Official sources

1. Official README
2. Project repository
3. Release notes