Apache Maka (Incubating): a local-first agent workspace you build from source

What Maka is for, and who should care

Maka is an agent workspace rather than a chat wrapper. The README describes it as inspecting projects, running tools under a sandbox boundary, and recording model messages and tool calls as recoverable execution facts on your machine, through one Runtime Host. That framing tells you the intended user: someone who wants an agent to touch a real codebase and wants to be able to reconstruct what happened afterwards.

The three surfaces map to three jobs. Desktop is for daily interaction, file and Artifact workflows, and model or permission setup. The TUI and CLI are for working in the current project directory or running a single non-interactive Turn through maka and maka run. Eval exists for reproducible benchmark experiments across Maka and external subjects. All three go through Runtime Host; the README states that Eval only owns the experiment and its scores.

If your interest is a hosted assistant that remembers you across devices, this is the wrong shape. Maka keeps sessions, settings and run records local by default, and you bring the model: a cloud API, a local model, or a compatible gateway. The value is the record and the sandbox boundary, not the model.

Runtime Host, the execution record, and what context trimming actually does

The architectural claim worth examining is that the record is kept. Model messages, tool calls, tool results, and how a turn ended are written down, and the README says the UI and the next model call are views of that record rather than the only copy. That inverts the usual arrangement where the transcript exists to feed the next request and is otherwise disposable.

One consequence is stated plainly: shorter context is not deleted history. Maka can omit old tool output from the next prompt without throwing away the saved evidence. For long sessions over a large repository, where tool output dominates the token count, this is the difference between a usable context window and starting over. The design also carries a durability promise: a durable execution record, crash recovery, and optional resume of an interrupted turn.

The tool surface is deliberately small. Built-in tools are Read, Write, Edit, Bash, Glob and Grep. Computer Use and catalog skills are optional and not on by default. Tools that leave the sandbox must be approved, runs can be aborted, and failures are classified. The Grep tool depends on ripgrep, which is why the requirements list it separately from Node and Git.

Installing Maka from source on an Apple Silicon Mac

There is no prebuilt download to recommend. The README states that Apache Maka has not made an Apache release yet, that anything published from the repository or a package registry was produced before or during incubation and is not an ASF release, and that until an approved source release exists it recommends no prebuilt download. Build from source instead.

You need Node.js 22.19 or newer (CI uses Node.js 24), npm, Git, and ripgrep for Runtime's Grep tool. The lockfile and scripts use npm, and the current packageManager field is npm 11.

Clone the repository, install with the lockfile, and start the Desktop development environment:

git clone https://github.com/apache/maka.git
cd maka
npm ci
npm run dev

npm run dev starts Desktop with HMR. If you want every workspace built before Electron starts, use npm run dev:full instead. The README also notes a case where dependency installation skipped the Electron binary: if dependencies were installed with ELECTRON_SKIP_BINARY_DOWNLOAD=1, install the Electron platform binary before starting.

Peer development is a separate path. Direct Peer and Peer Mesh work requires Rust stable 1.98 or newer plus the platform linker (Xcode Command Line Tools on macOS, MSVC Build Tools on Windows), and you must use the peer-enabled entry point so the native addon is built before Desktop starts:

npm run dev:peer       # HMR
npm run dev:full:peer  # full build

A first real use is to open the project you actually work in and let the agent read it. The CLI is the lower-friction entry: maka runs in the current project directory, and maka run executes one non-interactive Turn. Both share workspace and model connections with Desktop, so a model you configure once is available in either place.

Platform limits, incubation status, and the CLI beta label

The constraints are unusually explicit, and they matter more than the feature list. Desktop currently targets Apple Silicon Macs on arm64. Intel Macs and Linux are not supported yet. Windows is described as an unsigned preview, not a supported release tier, and links to docs/windows-support.md.

Incubation status is the second constraint. The README carries an ASF incubator notice stating that incubation is required of all newly accepted projects until a further review indicates the infrastructure, communications, and decision-making process have stabilized, and that it indicates the project has yet to be fully endorsed by the ASF. DISCLAIMER-WIP records the issues the project is currently aware of. A separate notice says data formats, CLI commands, and experimental capabilities may still change.

The release naming backs that up. The repository's most recent releases are v0.1.11 and v0.1.10 for Maka, plus cli-v0.1.0-beta.1 for the CLI. A beta tag on the command-line surface is a fair warning that scripts built on maka run may need rework. Chat apps, described as IM bots, are experimental and point to docs/architecture/bot-onboarding-runtime.zh-CN.md, which is written in Chinese.

Where Maka is the wrong tool: if you need a signed, versioned installer with a support commitment, or you run Linux or an Intel Mac, there is nothing here for you yet. The README is silent on rollback procedures for data formats that change between versions.

How Maka differs from a general-purpose coding agent CLI

A typical coding agent CLI is a stateless process: you invoke it in a directory, it reads files, calls tools, prints a result, and exits. Conversation history lives in the terminal or in a provider-side session. Maka splits that into a persistent local record plus a Runtime Host that all surfaces talk to, and it adds an evaluation layer on top.

The evaluation piece is the clearest difference. Maka expands declarative multi-arm experiments into task x repetition x subject cells, keeps immutable per-cell attempts with targeted infrastructure replacement and earliest-valid selection, and reports through a small result kernel covering score, normalized usage, attributable cost, duration, status, failure reason and artifacts. Maka subjects execute only through Runtime Host; external subjects use generic external subject adapters. A plain agent CLI has no equivalent, and building one around a different agent means reimplementing the harness.

The trade-off is weight. Maka is a TypeScript monorepo with eleven workspaces including packages/core, packages/storage, packages/mcp, packages/runtime, packages/runtime-host, packages/eval, packages/computer-use, packages/cli, packages/ui, apps/desktop and website. Peer features pull in Rust. If you want a single binary you drop into a container, this is a heavier commitment than the alternative.

Licence, maintenance and the cost of tracking an incubating project

Maka is licensed under Apache-2.0, and the root package.json carries the same identifier. The README's licence header and NOTICE file follow the ASF convention, which is consistent with the incubation effort. Apache-2.0 is permissive and includes a patent grant; that is a general property of the licence text, not advice about your situation. If you redistribute a build, the ASF release rules described in .github/ASF_SOURCE_RELEASE.md are worth reading, because the README states a convenience artifact is valid only when built from an approved source release.

The last push to the default branch was on 2026-08-18, the same day as the v0.1.11 release. That is recent enough that the repository is not dormant, but the README's own warning about changing data formats and CLI commands is the real upgrade cost. Every version bump is a possible migration for local session data, and the README does not document rollback. Pinning to a specific tag and reading CHANGELOG.md before upgrading is the practical posture.

Incubation adds a second kind of churn: project governance, release process and repository layout can change as the podling moves toward a first ASF release. None of that affects your local data, but it does affect where you file issues and how releases are named.

Editorial conclusion

Adopt Maka if you are on an Apple Silicon Mac, comfortable running npm ci and npm run dev from source, and want session records, tool approval and crash recovery to live on your own disk. Do not adopt it if you need a signed installer, a stable CLI contract, Linux or Intel support, or a project that has passed an Apache release vote. Verify first that Node.js is at least 22.19 and ripgrep is on PATH, then read DISCLAIMER-WIP and ARCHITECTURE.md before you point it at a real repository.

Frequently asked questions

Official sources

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