# I beat all the popular harnesses on FrontierHarness Eval

> Source: <https://github.com/tontinton/maki>
> Published: 2026-09-22 21:00:35+00:00

An AI coding agent optimized for minimal use of context tokens, while providing a great user experience.

[FrontierHarness Eval](https://frontierharness.org/) benchmark result, [click here to download report.zip](https://github.com/tontinton/maki/releases/download/v0.5.5/frontierharness-report-2026-09-19.zip)

- `index` tool - uses[tree-sitter](https://tree-sitter.github.io/tree-sitter) to parse supported programming languages to produce a high level skeleton of a file, with exact start-end lines of each item (e.g. a function's implementation is in lines 150-165). Encouraged to be used before reads. For my usage it adds 59 tok/turn but saves 224 tok/turn on read calls, saving 165 tok/turn.
- `code_execution` tool - uses[monty](https://github.com/pydantic/monty) to run an interpreter that has all other tools available as async functions. Maki uses it to filter / summarize / transform / pipe data to other tools as input, without it ever reaching and polluting the context window. Sandbox limited by time & memory.
- `task` tool - when delegating work to subagents, the AI chooses whether to run weak / medium / strong model of used provider. Think haiku / sonnet / opus.
- System prompt, tool descriptions, and tool examples are all concise, I've made sure not to bloat your context.
- Uses [rtk](https://github.com/rtk-ai/rtk) if you have it installed, disable with`maki.setup({ agent = { rtk = false } })` in your`init.lua` . Saves ~50% of bash output tokens. Remember bash is just 12% of total token usage, so 6% is nice, but saving on reads (65% of total) by using`index` gave me more benefit. I think I'll do bash output filtering like this myself in a future release.

- SUPER fast startup, 60 FPS, and light on memory. Not running any JavaScript, using [ratatui](https://ratatui.rs) for TUI. Even the splash screen animation uses SIMD.
- Extend with neovim like Lua plugins - [Builtin plugins](https://github.com/tontinton/maki/tree/main/plugins) ,[User made plugins showcase](https://github.com/tontinton/maki/discussions/452) ,[Lua API reference](https://maki.sh/docs/lua-api/) .
- Philosophy of not hiding anything - while other coding agents hide information as models improve (e.g. not showing number of lines read), maki leaves you in control.
- UI fits everything well on my small screen laptop.
- Full visibility of subagents - each subagent gets their own "chat window" you can easily navigate between using `/tasks` (Ctrl-X).
- Sensible permission system - when the agent runs `git diff && rm -rf /` , what do you think will happen in your current coding agent? It will treat it as`git *` . Maki uses tree-sitter to parse the bash command and figure out the permissions requested are`git *` and`rm *` . Disable using`--yolo` .
- SSRF protection on `webfetch` calls.
- A `memory` tool to keep long term context, just tell maki to remember something (sometimes it uses it automatically). Managed via`/memory` (view / edit / delete memories).
- Fuzzy search with Ctrl-F.
- `/btw` to run a command with the chat history without interfering with the current session.
- Rewind on Escape-Escape (no code rewind yet, only chat history).
- Attach images in prompts.
- 26 of the most popular themes.
- Resume sessions.
- Skills & MCPs.
- Opt-in [OpenTelemetry](https://maki.sh/docs/telemetry/) export, same format as Claude Code's.
- Plan mode.
- Run bash commands using `!` , or`!!` if you want maki to not know about it.
- `/cd` to change dir.
- Use `--print --output-format stream-json` to run UI-less. Output is compatible with Claude Code, so you can easily replace your existing solutions.

- Anthropic - `ANTHROPIC_API_KEY` only (using OAuth is against TOS). Bedrock supported via`CLAUDE_CODE_USE_BEDROCK=1` .
- OpenAI - `OPENAI_API_KEY` and OAuth via`maki auth login openai` .
- xAI - `XAI_API_KEY` and OAuth via`maki auth login xai` .
- Google - `GEMINI_API_KEY` .
- Copilot - `GH_COPILOT_TOKEN` or an existing GitHub Copilot sign-in at`~/.config/github-copilot/` .
- Ollama - `OLLAMA_HOST` for local (e.g.`http://localhost:11434` ), or`OLLAMA_API_KEY` for cloud.
- llama.cpp - `LLAMA_CPP_HOST` (e.g.`http://localhost:8080` ), optionally`LLAMA_CPP_API_KEY` .
- Mistral - `MISTRAL_API_KEY` .
- Z.AI - `ZHIPU_API_KEY` .
- DeepSeek - `DEEPSEEK_API_KEY` .
- OpenRouter - `OPENROUTER_API_KEY` .
- Requesty - `REQUESTY_API_KEY` . Set`REQUESTY_BASE_URL=https://router.eu.requesty.ai/v1` for the EU region.
- Synthetic - `SYNTHETIC_API_KEY` .
- Regolo - `REGOLO_API_KEY` . EU-hosted open-weight models.
- TensorX - `TENSORX_API_KEY` .
- OpenCode Zen - `OPENCODE_API_KEY` , or the free`public` key for zero-cost models. Models from the models.dev catalog.
- OpenCode Go - `OPENCODE_API_KEY` . Models from the models.dev catalog.
- Aperture - `APERTURE_HOST` (e.g.`https://your-host.tailnet.ts.net` ). No API key needed, Tailscale handles auth.

**Dynamic providers** - drop an executable script into `~/.config/maki/providers/` to add custom providers or proxies. See [docs](https://maki.sh/docs/providers/#dynamic-providers) for details.

Providers as Lua plugins WIP!

```
# Download and read the script first (don't blindly trust shell scripts).
curl -fsSL https://maki.sh/install.sh -o install.sh
cat install.sh

# Then run.
chmod +x install.sh && sh install.sh
```

One-liner:

```
curl -fsSL https://maki.sh/install.sh | sh
```

Installs to `~/.local/bin`. Override with `MAKI_INSTALL_DIR`.

```
# Download and read the script first (don't blindly trust remote scripts).
irm https://maki.sh/install.ps1 -OutFile install.ps1
Get-Content install.ps1

# Then run.
.\install.ps1
```

One-liner:

```
irm https://maki.sh/install.ps1 | iex
curl -fsSL https://maki.sh/install.sh | sh
```

Both install to `%LOCALAPPDATA%\maki` and add it to your user PATH. Override with `MAKI_INSTALL_DIR` / `$env:MAKI_INSTALL_DIR`.

```
cargo install --locked --git https://github.com/tontinton/maki.git maki
nix run github:tontinton/maki
```

Or download a pre-built binary from [GitHub Releases](https://github.com/tontinton/maki/releases/latest).

Run `maki acp` or configure your ACP supporting editor to use maki, e.g. in [Zed](https://zed.dev/)'s `settings.json`:

```
"agent_servers": {
  "Maki": {
    "default_config_options": {
      "model": "deepseek/deepseek-flash"
    },
    "type": "custom",
    "command": "maki",
    "args": ["acp"],
    "env": {}
  }
}
```

More info at the [official docs](https://maki.sh/docs).

[tontinton/makiconf](https://github.com/tontinton/makiconf) - includes a [semble](https://github.com/MinishLab/semble) tool (Lua code) for semantic code search, and an [ast-grep](https://ast-grep.github.io) MCP server for AST-based search and replace.

DISCLAIMER: >90% of code in maki was written by maki, guided by humans. Some parts of the code are not as good as what I would've made in the artisanal hand-made style. But it's also not slop / vibe coded, and can easily be refactored if needed nowadays.