Who maka is for#
Developers running multi-step agent tasks locally
Maka's Desktop and CLI surfaces let a developer run agent tasks that read, write, and execute code in the current project directory without sending execution history to a vendor. The permission engine gates each tool call, so the developer retains control over what the agent does at every step.
Skip if:
You need a managed, zero-setup agent runtime with no infrastructure responsibility. Maka requires configuring your own model connection and, for the Desktop app, running on macOS Apple Silicon.
ML engineers running model evaluation experiments
The Eval harness runs declarative multi-arm experiments with attributable cost, duration, and failure reason per attempt cell. Maka subjects run through the same Runtime Host as interactive sessions, so evaluation and production execution paths stay consistent.
Skip if:
You need a hosted evaluation platform with team collaboration, shared dashboards, and no local setup. Maka's eval output is local and file-based with no built-in remote sharing.
Teams that cannot send agent traces to third parties
Organizations with data-residency requirements or compliance policies can run Maka entirely on local infrastructure. No execution trace, session message, or model usage record leaves the machine unless the configured model API itself sends data outbound.
Skip if:
You need centralized team dashboards, shared session history across machines, or cloud-based collaboration on agent runs. Maka is single-machine by default with no built-in sync or multi-user access.
Developers building and benchmarking multi-step agent workflows
Graph mode (via the --graph flag in the CLI or /graph command in the TUI) runs complex multi-step plans in isolated Git worktrees, waits for the durable graph to complete, and surfaces the final supervisor output. This fits structured agent development where reproducibility matters.
Skip if:
Your workflow requires direct integration with existing CI/CD pipelines or cloud orchestration. Maka's graph mode uses local Git worktrees and does not natively export to external orchestration systems.
The problem it solves#
Running AI agents on cloud-hosted platforms means your execution traces, session history, tool call decisions, and model usage records all live on vendor infrastructure. If the vendor changes their pricing, deprecates an API, or suffers an outage, your agent history and debugging context go with it. Teams that handle sensitive data or operate under compliance requirements often cannot use hosted observability platforms at all.
Even for teams without strict data requirements, the opacity of agent execution is a real pain: an interrupted run means losing context, a failed tool call is hard to trace, and the cost of a long multi-step task is rarely attributable to individual steps. Most teams either accept these gaps or bolt together separate logging and retry systems that only partially cover the problem.
How it solves it#
Append-only Runtime Event Log
Every model message, tool call, tool result, permission decision, and termination event is recorded in an immutable log. Sessions, UI state, model context, and recovery paths are projections over this log, not separate databases. Interrupted turns can be resumed with full context intact, and past decisions reviewed without reconstructing state.
Three execution surfaces from one Runtime Host
Run Maka as a Desktop app (Electron and React, macOS Apple Silicon), a TUI or CLI for terminal-first and non-interactive tasks, or an Eval harness for multi-arm benchmark experiments. All three surfaces share the same workspace, model connections, and permission settings.
Permission-gated local tool runtime
Built-in tools include Read, Write, Edit, Bash, Glob, and Grep. All file writes, shell calls, and sensitive operations pass through a permission engine before execution. The renderer never receives plaintext credentials; permission decisions are logged alongside tool calls in the Runtime Event Log.
Multi-provider model connections
Connect to any cloud API, local model, or compatible gateway. Maka does not bundle a shared model account. You configure and test your own connections under Settings > Models, and Maka normalizes provider-specific errors and accounts for usage and cost across all providers.
Reproducible evaluation experiments
The Eval harness runs declarative multi-arm experiments expanded into task x repetition x subject cells. Each cell attempt is immutable, with a result kernel covering score, normalized usage, attributable cost, duration, status, and failure reason. Maka subjects execute through Runtime Host; external tools use generic adapter interfaces.
Session branching and recovery
From the Desktop workspace, create, archive, search, rename, retry, regenerate, or branch sessions from any turn. Startup recovery can resume interrupted agent runs, with a safe-boundary opt-in via environment flag to prevent unintended model calls on restart.
Strengths and trade-offs#
Strengths
- All execution data stays on your machine by defaultSessions, run records, model usage, credentials, and settings are stored in local SQLite and configuration files under Electron userData. No execution trace is sent to a third-party platform unless your configured model connection calls an external API. Credential storage uses POSIX directory mode 0700 and file mode 0600.
- Apache 2.0 license with no usage restrictionsThe Apache 2.0 license permits commercial use, modification, and distribution without requiring source disclosure or payment. Unlike proprietary LLMOps platforms that charge per trace or per seat, Maka has no metered billing beyond whatever model API you connect to.
- Log-as-runtime design enables true recoveryThe Runtime Event Log is the single source of truth: UI, model context, and session state are all derived from it at read time. Recovery from an interrupted turn is architectural, not an afterthought, and historical runs can be inspected without a separate logging system.
- Bring-your-own model with local inference supportMaka supports cloud APIs, local models, and compatible gateways, and distinguishes configured, send-ready, and experimental connection states. You are not locked to one provider's models or pricing, and local models keep inference private with no outbound API calls.
Trade-offs
- -macOS Apple Silicon only for signed Desktop buildsThe signed and notarized Desktop app targets Apple Silicon Macs only. Intel Macs, Windows, and Linux have no supported release tier as of the first public build. Windows has an unsigned preview for developers who verify the SHA-256 checksum, and Linux requires building from source.
- -Under active development with format instabilityMaka is in Apache Incubation and carries an explicit notice that data formats, CLI commands, and experimental capabilities may still change. Upgrading can break earlier workspace data: this storage generation does not import legacy File/JSONL session histories, and pre-existing credential files are not migrated automatically.
- -No bundled model account or shared inferenceMaka does not provide a shared model API key or bundled inference tier. You must configure your own model connection before running any agent task. This is intentional for privacy, but it is a non-trivial first step for users unfamiliar with API key management or local model runtimes.
- -Phase 3 tool reconciliation not yet implementedAmbiguous tool outcomes from interrupted runs are parked rather than retried. Phase 3 reconciliation for indeterminate tool side effects is not yet implemented, so some interrupted agent tasks cannot be cleanly resumed and require manual review of what was partially completed.
maka vs alternatives#
Maka vs LangSmith
LangSmith is a cloud-hosted observability and evaluation platform for developers building LLM applications. It captures traces, runs evaluations, and stores execution data on LangChain's infrastructure. Maka is a local-first agent workspace: it records the same execution facts (model messages, tool calls, tool results, decisions) but stores them in a local SQLite database rather than a cloud backend.
| Feature | Maka | LangSmith |
|---|---|---|
| License | Apache-2.0 | Proprietary |
| Data storage | Local SQLite on your machine | LangChain cloud |
| Self-hosting | Yes (build from source) | No (cloud-only) |
| Agent runtime | Built-in (Desktop, TUI, CLI) | External (you bring your framework) |
| Evaluation | Built-in local Eval harness | Managed evaluation datasets and runs |
| Team collaboration | Not built-in | Yes (shared dashboards, datasets) |
Maka is the better choice when data residency matters, when you want to avoid sending execution traces to a third-party cloud, or when you run agents as a personal developer tool rather than as an application you are building and deploying. LangSmith remains the better fit when you need team-wide shared trace history, managed evaluation datasets, or tight integration with LangChain's framework ecosystem.
Maka vs Vellum AI
Vellum AI is a proprietary platform for building, testing, and deploying LLM-powered workflows, with prompt management, evaluation, and deployment tooling behind a cloud dashboard. Maka does not offer prompt management or a deployment target: it is an agent workspace for running tasks locally, not a platform for shipping LLM features to end users.
| Feature | Maka | Vellum AI |
|---|---|---|
| License | Apache-2.0 | Proprietary |
| Data storage | Local SQLite on your machine | Vellum cloud |
| Prompt management | No | Yes |
| Agent execution | Built-in Runtime Host | External (via API) |
| Evaluation | Multi-arm local experiments | Managed cloud evaluation |
| Deployment target | None (local workspace) | Yes (production endpoints) |
Maka fits developers who run agent workflows for their own productivity or research, rather than teams shipping LLM features to end users. Vellum AI is the better choice when you need a managed path from prompt iteration to production deployment with team visibility and cloud hosting included.
Install and self-host#
Install ripgrep (required for the Grep tool) and clone the repository to set up the Maka Desktop development environment.
```bash
brew install ripgrep
git clone https://github.com/apache/maka.git
cd maka
npm ci
npm run dev
```What it's built on#
- Languages
- JavaScriptRustTypeScript
- Frameworks
- React
- Tooling
- esbuild
FAQ#
Is Maka free to use?
Yes. Maka is Apache 2.0 licensed, which permits free use, modification, and commercial deployment with no metered billing. You do need to supply your own model API key or run a local model: Maka does not bundle inference or a shared cloud account. Your only cost is the model API usage you incur from your configured provider.
Does Maka send my agent sessions or execution logs to a cloud service?
No. All sessions, messages, tool call records, and credentials stay on your local machine by default in an SQLite database and configuration files under Electron userData. The only outbound traffic is to whatever model API or gateway you configure yourself. Maka has no telemetry backend or cloud storage layer.
What operating systems does Maka support?
The signed Desktop app targets macOS Apple Silicon (arm64) only as of the first public release. An unsigned Windows preview is available for developers who verify the SHA-256 checksum before running it. Intel Macs and Linux require building from source. The TUI and CLI share the same workspace and model connections as the Desktop app on supported platforms.
How does Maka differ from LangSmith or Vellum AI?
LangSmith and Vellum AI are hosted, cloud-based platforms for tracing, evaluating, and deploying LLM applications. They require a cloud account and store execution data on their infrastructure. Maka is a local-first workspace: execution logs, session history, and credentials stay on your machine, and you bring your own model connections. The tradeoff is that Maka has no shared team dashboards or managed cloud infrastructure.
Can I use Maka with local offline AI models?
Yes. Maka supports local model connections alongside cloud API connections. Configure a local model runtime under Settings > Models, and Maka routes inference locally without outbound API calls. This keeps both execution history and inference entirely on your machine. Maka distinguishes configured, send-ready, and experimental connection states, so a local model that is not fully wired into Runtime is not presented as usable until it is ready.
Similar open-source tools#
guaardvark
Self-hosted AI workstation with agents, video, voice, and RAG.
thoughtdag
Make LLM context visible, editable, and graph-structured
lumina
Local-first AI agent that learns, remembers, and never phones home
Caveman
Token-slashing caveman-speak for cheaper, faster AI code.
Claudoscope
Free macOS app for browsing and managing Claude Code sessions
Breadcrumb
Open source LLM tracing and monitoring for AI agents