Daimonos

Daimonos

An agent-optimized OS layer that makes AI coding agents faster and cheaper.

Daimonos replaces the built-in file, search, exec, and git tools in your AI coding agent with structured equivalents that return compact JSON instead of raw terminal output. The result: fewer tokens consumed, fewer round-trips, and lower API costs — with zero changes to your workflow.

Platforms: Linux (x86_64, aarch64) and macOS (Apple Silicon, Intel). Windows support is planned.

For repository agent/operator conventions, see AGENTS.md (especially Daimonos tool usage policy).

The name comes from Greek *daimon* (agent/spirit), the etymological root of "daemon."

The problem

When an AI agent runs cargo test, it gets back hundreds of lines of terminal output — progress bars, compile messages, passing test names — when all it needs is "47 passed, 0 failed." The agent pays for every token of that noise: reading it, reasoning about it, and carrying it in context for the rest of the session.

The same waste happens with git status, docker ps, ls -la, and every other shell command. Agents spend 30-50% of their token budget on verbose, unstructured tool output.

How it works

Daimonos runs as an MCP server that your IDE or CLI spawns automatically. It provides the same operations agents already use — read files, write files, search, execute commands, git operations — but returns compact, structured JSON instead of raw text.

The single binary also provides ACP, one-shot agent, interactive chat, and socket-daemon runtimes — a full coding-agent harness in its own right; see Agent harness features below and Runtime modes for the explicit subcommands and compatibility aliases.

Agent: exec("cargo test")

Without Daimonos (raw terminal output): Compiling inventory v0.1.0 (/workspace) Finished test profile [unoptimized + debuginfo] target(s) in 2.31s Running unittests src/main.rs (target/debug/deps/inventory-abc123) running 47 tests test config::tests::test_default ... ok test config::tests::test_load ... ok ... (200+ more lines) test result: ok. 47 passed; 0 failed; 0 ignored

With Daimonos (structured JSON): {"ok":true,"tests":47,"passed":47,"failed":0,"failures":[]}

Four layers of optimization

1. Native tool plugins — git, cargo, gh, and docker are exposed as first-class MCP tools with structured JSON output. When agents call exec("cargo test"), Daimonos intercepts it and routes through the native plugin instead.

1. Semantic output filters — For commands without native plugins (pytest, make, pip install, eslint, etc.), Daimonos applies semantic compression: test runners return summary + failures only, build commands return "ok" or just the errors, install commands return success/failure.

1. Protocol-level efficiency — Read deduplication (re-reading an unchanged file returns {"unchanged":true} instead of the full content), compact field names, lazy tool exposure, batch operations, and a terse output directive that cuts LLM prose by ~30%.

1. Managed subprocess execution — Command output is bounded while it is read instead of after full buffering. Daimonos owns Unix process groups, retires descendants on cancellation or session shutdown, isolates child environments through an explicit allowlist, and stores background output in private bounded artifacts.

Benchmark results

Tested with Claude Opus 4.6 on identical coding tasks (read files, search code, edit, run tests, git operations):

Remote benchmarks on AWS (same hardware, same model, same tasks) showed 20.3% cost reduction and 14.0% faster task completion.

SWE-bench Verified (mini) — three-way harness comparison

Five instances from swe-bench-verified-mini, same model (Claude Opus 4.8) across all three harnesses, each agent running inside the official SWE-bench Docker image for its instance (real test environment), scored with the official swebench evaluation harness:

Conclusions:

• Correctness parity: all three harnesses resolved 5/5 at this sample size, so daimonos's token savings did not cost any resolutions.
• daimonos was cheapest and fastest: ~30% fewer tokens than mini-swe-agent (the minimal open-source baseline) and ~4.8x fewer than cursor-agent, with ~3x less wall time than either.
• Caveats: n=5, and run-to-run variance is real (daimonos spent 503k tokens on sphinx-8035 in an earlier identical-config run vs 173k here). cursor-agent's total is mostly cache-read tokens billed at a fraction of input price, so its raw token count overstates its relative cost. Measured API spend for the batch (OpenRouter): daimonos $1.53, mini-swe-agent $1.66; cursor-agent bills via Cursor's backend.

See benchmarks/swebench/ for the runners and methodology.

60-second demo

Use this script for README readers, release notes, and social posts:

# 1) Install daimonos

cargo build --release sudo cp target/release/daimonos /usr/local/bin/

2) Configure your MCP client (example: Cursor)

.cursor/mcp.json -> command: daimonos, args: ["--mcp", "-w", "/path/to/project"]

3) Ask your agent to run:

"Run cargo test and summarize failures only."

"Show git status as structured output."

What to highlight in the demo:

• same workflows, less tool-output noise
• structured responses instead of raw terminal spam
• fewer tokens and fewer round-trips for common coding tasks

Quick start

Install

Pre-built binaries (Linux and macOS):

# Linux x86_64

curl -L https://github.com/beardfaceguy/daimonos/releases/latest/download/daimonos-x86_64-linux.tar.gz | tar xz sudo mv daimonos /usr/local/bin/

macOS Apple Silicon

curl -L https://github.com/beardfaceguy/daimonos/releases/latest/download/daimonos-aarch64-macos.tar.gz | tar xz sudo mv daimonos /usr/local/bin/

From source:

git clone https://github.com/beardfaceguy/daimonos.git

cd daimonos cargo build --release sudo cp target/release/daimonos /usr/local/bin/

See docs/install.md for all platforms (ARM Linux, Intel Mac, musl static builds).

Configure your IDE

For most users, start with one of these:

• Cursor: Cursor IDE setup
• Zed: Zed setup
• Claude Code: Claude Code setup

Add Daimonos as an MCP server. For Cursor, add to your project's .cursor/mcp.json:

{

"mcpServers": { "daimonos": { "command": "daimonos", "args": ["--mcp", "-w", "/path/to/your/project"] } } }

That's it. Daimonos starts when your IDE opens the project and exits when you close it. No daemon to manage, no background service.

Setup guides for other tools

• Cursor IDE
• GitHub Copilot (VS Code, Visual Studio, JetBrains, Xcode, Eclipse)
• Claude Code (CLI + macOS Desktop app)
• Windsurf
• Cline (VS Code extension)
• Gemini CLI
• Zed Editor
• Discord integration (bot token, allowlists, read-only tools)
• Other tools (Claude Desktop, ChatGPT, Continue.dev, BoltAI, etc.)

What's included

Core tools (always available)

Native tool plugins (auto-detected)

These appear automatically when the corresponding CLI tool is found on PATH:

Additional capabilities

• Workspace snapshots — Checkpoint before risky edits, rollback on failure
• Starlark scripting — Bundle multiple tool calls into a single script
• Token analytics — Per-tool-call tracking with cross-session history (daimonos --stats)
• Background processes — Start, poll, and stop long-running commands with admission limits, private bounded logs, and descendant cleanup
• Configurable — All tunables in a single TOML config file

Managed process lifecycle

Raw exec, background jobs, and CLI plugins (cargo, git, gh, docker, npm, pytest, curl, and shellcheck) share one managed execution layer:

• Streaming-time bounds — stdout and stderr retain UTF-8-safe head/tail previews without first allocating the complete output
• Process-group ownership on Unix — cancellation and shutdown send TERM, wait a configurable grace period, then escalate to KILL and reap descendants
• Secure background artifacts — random exclusive 0600 files under a private 0700 directory, with configurable byte and job-count limits
• Environment isolation — children inherit only configured parent variables plus explicit session, tool, and per-call overrides; provider and MCP credentials are not ambiently leaked
• Structured-output integrity — plugins reject truncated JSON rather than reporting an incomplete result as valid

Agent harness features

Beyond the MCP server, the same binary is a complete coding-agent harness: an interactive terminal UI (daimonos agent), an ACP backend for Zed, a one-shot CLI, and a session daemon with attach/detach and remote control.

Many of its recent features come from a systematic study of 60+ open-source agent harnesses (Ai