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. Model messages, tool calls, tool results, and how a turn ended are written down as execution facts. 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 README explicitly 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 should get the same sandbox rules, the same tool set, 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 mentions crash recovery and optional resume of an interrupted turn, 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, tool result, and turn ending is written down. The UI and the next model call are both derived from that record. This is different from a typical chat log because it is structured enough to support branching, retrying, and resuming. The desktop workspace lets you branch sessions from a Turn, retry a turn, regenerate a response, and search past sessions. 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 is explicit: Apache Maka has not made an Apache release yet. Everything published from the repository or a package registry is not an ASF release and has not been reviewed by the Incubator PMC. Therefore, the README recommends no prebuilt download. You must build and run from source. The requirements are Node.js 22.19 or newer, npm (the packageManager is npm 11), Git, 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. The CLI is also available, with commands like maka and maka run. The eval surface uses maka eval run <spec> --out <directory>. 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, but it is the only officially recommended path.

Sandbox Boundaries and Tool Approval

Maka runs tools under a sandbox boundary. The built-in tools are Read, Write, Edit, Bash, Glob, and Grep. Tools that leave the sandbox must be approved. This is a permission model that gives the user control over potentially dangerous operations. The README says that runs can be aborted and failures are classified. That means the runtime distinguishes between different kinds of errors, which is useful for debugging. Computer Use and catalog skills are optional and not on by default. That is a conservative default. The sandbox is not a full security boundary in the sense of a VM; it is a policy layer that requires approval for certain actions. The exact rules are not detailed in the README, so you would need to inspect the source or the architecture document to know what counts as leaving the sandbox. This is a limitation: the documentation is thin on the specifics. For a tool that handles code execution, the sandbox is the most important feature, and the README only gives a high-level description. You should verify the sandbox implementation before trusting it with sensitive work.

Evaluation: Reproducible Benchmarks with a Small Result Kernel

The eval surface is a separate tool for reproducible benchmark experiments. It runs declarative multi-arm experiments that expand into task × repetition × subject cells. Each attempt is immutable, with targeted infrastructure replacement and earliest-valid selection. The result kernel is small: it records score, normalized usage, attributable cost, duration, status, failure reason, and artifacts. This is designed for comparing Maka against external subjects. Maka subjects execute only through Runtime Host, while external subjects use generic external subject adapters. This separation is important because it ensures that Maka is not evaluated differently from other agents. The eval tool is a differentiator. Many agent frameworks do not come with a built-in evaluation harness. Here, it is a first-class surface, which suggests the project cares about measurable performance. However, the README does not provide examples of eval specs or how to write them. You would need to read the docs or the source to understand the spec format. That is a gap for someone who wants to start benchmarking immediately.

Limitations and Wrong Use Cases

The most obvious limitation is platform support. Desktop currently targets Apple Silicon Macs only. Intel Macs and Linux are not supported. Windows is an unsigned preview, not a supported release tier. If you are on a Linux workstation or an Intel Mac, Maka is not for you yet. 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 lack of an Apache release also means there is no official binary distribution. You have to build from source, which requires Node.js, npm, ripgrep, and possibly Rust. That is a significant setup cost. The sandbox is another concern. The README gives a high-level description but not the details of what rules apply. If you need a hardened sandbox for untrusted code, you should look elsewhere or wait for more documentation. Finally, the project is incubating at Apache, which is a process that may take years. The DISCLAIMER-WIP file records known issues, but the README does not list them. You would need to read that file to understand what is broken.

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. Aider, for example, is a terminal-based tool that edits code in a git repository. It does not have a durable execution record in the same way; it relies on git history for recovery. Maka's record is at the level of tool calls and model messages, which is more granular than a commit. Aider also does not have a sandbox or an eval harness built in. 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. The closest in approach might be something like OpenHands, which also runs agents locally and has a sandbox, but Maka's focus on a durable, recoverable execution record is its distinguishing feature. The README does not mention any direct competitors, so this comparison is based on general knowledge of the ecosystem.

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 README includes a disclaimer that incubation status is not a reflection of completeness or stability. The project is under active development, with recent releases like v0.1.11 and cli-v0.1.0-beta.1. The last push was on 2026-08-18, which suggests regular activity. But the maintenance cost is on you. Because there is no stable 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. The README does not provide an upgrade path. 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 a stable, supported release, Intel Mac or Linux support, or a prebuilt installer. 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. Maka is not yet an Apache release, so any published artifact is a convenience build, not an ASF-approved one.

Official sources

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