Apache Maka

Maka is an agent harness built around a simple, powerful idea: the log of everything that happens is the runtime. This makes it reproducible by design, which is why it performs well on benchmarks. You bring your own model, and it runs locally, giving you a complete record of every tool call and permission decision. The catch is that it has no sandbox, so you are giving the agent direct access to your terminal and file system, which is a significant risk on a real repository.

Since it is an incubating Apache project without a formal release, you have to build it from source. The project's longevity is tied to the foundation, which is a good bet, but it's not a polished product yet. Pick Maka if you are a researcher or building your own agent tooling and need a reliable, auditable harness. Pick something with a sandbox if you need to run agents against your production codebase.

Apache Maka has no Docker sandbox. It grants agents direct terminal access on the host operating system. A mistake or a malicious model can execute any command, including file deletion or data exfiltration, without isolation. The documentation states permission is requested before the agent "leaves the sandbox," but the specifications confirm no sandbox exists. This creates a significant security risk for any user.

The tool is free and open-source under the Apache Foundation. It publishes its benchmark methodology and results. The append-only log is a correct design for reproducibility and debugging agent behavior.

Apache Maka is presented as a high-performance agent workspace. Its architecture is its most distinct feature: every action, from model messages to tool calls and permission decisions, is recorded as an immutable RuntimeEvent in an append-only log [1]. The user interface and runtime state are projections of this log, a principled design that ensures a complete record of any session. This log-centric approach is documented as the basis for crash recovery and reproducibility [2].

The project reports benchmark scores on Terminal-Bench 2.1, including comparisons to other harnesses, and makes the per-task results available [2]. However, the system executes commands directly on the host without a documented sandbox [SPEC ROW]. This means any agent action, if approved, has the same permissions as the user running Maka, a considerable security consideration for any task involving untrusted code or dependencies.

Apache Maka is a classic open-source play, but under the Apache Software Foundation umbrella, which changes the calculus. There's no venture funding to run out, no cap table to worry about, and no pricing power to speak of because it's free. The focus on reproducibility and local execution is a strong differentiator, a real moat against cloud-only tools. Its usefulness is demonstrated by solid benchmark performance against other harnesses.

The critical path here is community adoption and contribution. Without a commercial entity driving a roadmap, ASF projects live or die by the maintainers they can attract. The lack of a Docker sandbox is a notable security gap for a tool that executes arbitrary code. The most likely outcome is that it becomes a foundational component absorbed into a larger commercial platform. The acquirer isn't buying a company, they're hiring the committers. Position: adopt for individual use; for team-wide dependency, track committer velocity as your primary health metric.

Apache Maka is presented as a high-performance agent workspace with an append-only log of all operations. It is free, open-source, and runs locally, which addresses cost and data privacy at a surface level. However, it is an incubating project with no formal releases, no SSO, no SCIM, and no audit logs beyond the local session record. There is no central management or enterprise support path.

This is a tool for individual developers, not a managed solution for a team. The lack of a security sandbox for terminal execution, combined with the absence of centralized policy controls, creates an unacceptable risk profile at our scale. We cannot deploy, monitor, or secure it. Not yet.

Maka is what I'm talking about. It's an Apache project, so the license is real, and the source is right there. The whole design is built around an append-only log of RuntimeEvents—every model call, every tool use, every permission decision is recorded. This isn't just for history; the entire state is a projection of that log. It's built for local execution, supports my own models, and has no cloud component to get in the way. It's still incubating, and there's no server-side MCP, but the foundation is solid.

The lack of a Docker sandbox for terminal_exec is a risk, but one I'm willing to take on my own machine. The fact that I can build the desktop and CLI from source (npm run build) and point it at any compatible endpoint means I own the stack. It's a tool for people who want to measure performance and trust the record, not a black box.