Detailed comparison
pi is a flexible harness with a great extension ecosystem. miii is a privacy-first agent that runs local by default — but also works with Claude Opus 4, OpenAI o3, or any OpenAI-compatible endpoint.
The real differentiator is Beacon: a context engine that makes small local models viable for deep agentic work, and makes cloud models far more efficient. pi has no equivalent.
Pi — flexible harness, 50+ extensions, 15+ cloud providers, session branching. miii — privacy-first defaults, Beacon, shadow git, OS sandbox, call graph — all built-in. pi wins on extensibility. miii wins on defaults.
Feature matrix
| miii | pi | |
|---|---|---|
| Default provider | Ollama (local, offline) | Cloud (Anthropic / OpenAI / etc.) |
| API key required to start | ✗ | ✓ |
| Works fully offline | ✓ | ✗ |
| Code sent to cloud | Only when configured | Every request |
| Goal-aware context (Beacon)★ | ✓ | ✗ |
| Per-tool context compression★ | ✓ | ✗ |
| Dynamic context window★ | ✓ auto-detected | hardcoded guess |
| Shadow context store★ | ✓ | ✗ |
| OS-level shell sandbox | ✓ built-in | opt-in extension |
| Shadow git (model edit log) | ✓ | ✗ |
| File snapshots + Esc rollback | ✓ | ✗ |
| Live diff permission modal | ✓ built-in | opt-in extension |
| Static call graph (AST) | ✓ | ✗ |
| Windowed file reads | ✓ | ✗ |
| Semantic vector index | ✓ | ✗ |
| Anthropic support | ✓ | ✓ |
| OpenAI support | ✓ | ✓ |
| OpenAI-compat endpoints | ✓ | Via models.json |
| 15+ cloud providers native | ✗ | ✓ |
| Session branching / tree | ✗ | ✓ |
| HTML export / gist share | ✗ | ✓ |
| Extension ecosystem | small | 50+ TypeScript extensions |
| MCP support | ✓ | ✓ |
| License | MIT | MIT |
1 — Privacy & local-first
miii defaults to Ollama — fully offline, no API keys, no telemetry. When you need more power, you configure a cloud provider. pi supports local models as one option among many but is built around cloud APIs. Privacy is not a first-class design constraint in pi.
Cloud escalation via /cloud fires a single turn to Opus 4 or o3 without switching the session permanently.
pi defaults to and is built around cloud APIs. Local models are available as one provider choice, but the UX and defaults assume a cloud connection.
For regulated industries — fintech, healthcare, legal, defence — pi's default means every task, every file read, every prompt leaves the machine.
| miii | pi | |
|---|---|---|
| Default provider | Ollama (local, offline) | Cloud (Anthropic / OpenAI) |
| API key required to start | ✗ | ✓ |
| Works fully offline | ✓ | ✗ |
| Zero cost local runs | ✓ | ✗ |
| Code sent to cloud | Only when configured | Every request |
2 — Context engine
pi auto-compacts older messages when approaching context limits: wait for context to fill, call the LLM to summarise, pay tokens, wait for latency, resume. On Ollama this also means queue contention — the model serialises requests, so a summarise call blocks the agent call. miii's Beacon engine replaces this entirely.
Context window at each depth
Beacon applies a different compression strategy per tool type based on age and position. No LLM is called. No tokens spent. No latency. File reads become filename + line count + first 4 lines. Command output becomes first 4 lines + last line. Failures always kept verbatim.
After ~10 tool calls, models routinely forget the original task. Beacon extracts your goal synchronously at depth 0 (no LLM call), then injects a live goal-state block just before the last message at every depth. The model cannot lose the thread.
pi hardcodes a conservative context limit and compacts early. miii detects the actual window at session start: Ollama via live /api/show, Anthropic via model prefix lookup (200K for Opus 4 / Sonnet 4). Claude users get 14× more headroom before compaction triggers.
Everything Beacon compresses is preserved in a shadow store. Content is condensed, not deleted. The full original remains accessible. pi has no equivalent.
Extracted at depth 0, injected just before the last message at every subsequent depth. No LLM call. Single split. Every response.
How Beacon compresses each tool
| Tool result | Reduction |
|---|---|
| read_file (800 lines) | 97% |
| list_files (full tree) | 84% |
| run_command (stdout) | 95% |
| run_tests (output) | 90% |
| Error messages | — |
For Ollama users specifically
Beacon is the difference between a task completing and the context window crashing. An 8K-context model hits the wall at depth 6–8 on a complex task. With Beacon, the same model runs to depth 20. pi's LLM-based compaction creates queue contention on Ollama — the compaction call blocks the agent call.
3 — Codebase understanding
Every structural question in pi costs file reads — the full file, verbatim, into context. miii builds a complete symbol call graph of the codebase using pure AST analysis. No model. No network. Sub-second build.
Every function, class, method, and call edge across the codebase. Sub-second build. When a structural question arises mid-task, the agent queries the graph instead of reading files.
Reads imports, a focused region around the edit target, and the file footer. A 500-line file costs ~480 tokens instead of ~2000. pi reads full files.
Embed every file, store vectors locally via Ollama embedding model. Semantic search over the codebase without sending data to the cloud.
Why this matters for local models
Context beats parameters — providing the right structural facts to a 7B model is more effective than hoping a large model infers the same structure from raw files. The call graph makes small models answer architectural questions correctly.
4 — Safety & reversibility
pi offers permission gates, sandboxing, and shadow git as optional extensions — not defaults. miii ships all of these built-in and hardened. You don't configure safety; it's on.
| miii | pi | |
|---|---|---|
| Live diff + permission modal | Built-in — every file write | Opt-in extension |
| Shadow git model edit log | Built-in — every successful edit | Not included (partial via extension) |
| File snapshots + Esc rollback | Built-in — survives crashes | Not included |
| OS-level shell sandbox | Built-in (sandbox-exec / bwrap) | Opt-in extension |
| Failure decompose nudge | Built-in — triggers on 2nd failure | Not included |
5 — Provider support
pi natively supports 15+ cloud providers. miii covers Anthropic + OpenAI + any compatible endpoint — which covers ~95% of developer use cases — plus the deepest Ollama integration of any agent.
| Provider | miii | pi |
|---|---|---|
| Ollama (local) | First-class: auto-start, exact context window via /api/show, in-TUI model pull | Supported as one provider |
| Anthropic (Opus 4, Sonnet 4) | Yes (ANTHROPIC_API_KEY) | Yes |
| OpenAI (o3, o4-mini, GPT-4o) | Yes (openai-compat mode) | Yes |
| Azure / Bedrock / Groq / xAI | Via openai-compat endpoint | Native support for all |
| Custom endpoints (vLLM, LM Studio, llama.cpp) | Yes, context auto-detected | Via models.json |
| Per-turn cloud escalation | /cloud → Opus 4 / o3 | No equivalent |
6 — Extensibility
pi wins
pi's TypeScript extension architecture with 50+ examples lets you wire in anything: sub-agents, plan mode, permission gates, sandboxing, SSH execution, path protection. The tradeoff: you need to configure them.
miii ships with the most important capabilities built-in. The extension surface is smaller but the defaults are production-grade.
7 — Session & history
| Session branching / tree | ✗ | ✓ |
| HTML export | ✗ | ✓ |
| GitHub gist sharing | ✗ | ✓ |
| Shadow git model log | ✓ | ✗ |
| Esc full rollback | ✓ | ✗ |
| Memory extraction on /compact | ✓ | ✗ |
pi wins on session navigation. miii wins on safety.
8 — Agentic depth & task modes
| miii | pi | |
|---|---|---|
| Max tool-call depth | 20 (explicit cap) | Unbounded / extension-defined |
| /plan mode | Built-in | Extension |
| /tdd mode | Built-in (red → green loop) | Not included |
| /refactor with checkpoints | Built-in | Not included |
| /compact with memory extraction | Built-in | Auto-compaction (no extraction) |
| Cloud escalation | /cloud (one-turn Opus 4 / o3) | Switch model mid-session |
| MCP support | ✓ | ✓ |
Verdict
Bottom line
Pi is the right choice if you need maximum provider flexibility and a composable extension system.
miii is the right choice if you want an autonomous coding agent that defaults to your hardware — free, private, offline — but can escalate to Claude Opus 4 or o3 when the task demands it, all while Beacon keeps the model on-task through deep tool chains that would stall any naive agent. The local default is the differentiator; the cloud support means you never hit a wall.