# EONYX vs Claude Code: an honest comparison


**EONYX** and **[Claude Code](https://www.anthropic.com/claude-code)** are both terminal AI agents for code.
The workflow rhymes: [MCP](https://modelcontextprotocol.io), skills, hooks, subagents, plan mode, sessions.
The difference is architecture and freedom.
Claude Code is bound to the cloud and to [Anthropic](https://www.anthropic.com) models.
EONYX is not.

<!--more-->

## 🔀 How EONYX is different

Five practical differences.
All of them follow from one decision: no lock-in to a cloud or a vendor.

### Model freedom

Claude Code runs Claude models only.
EONYX connects to **any OpenAI-compatible API**.

- [OpenAI](https://openai.com), [OpenRouter](https://openrouter.ai), [DeepSeek](https://www.deepseek.com), [Moonshot](https://www.moonshot.ai) and other cloud providers.
- Local servers: **[Ollama](https://ollama.com), [llama.cpp](https://github.com/ggml-org/llama.cpp), [LM Studio](https://lmstudio.ai)**.

A model is one entry in `eonyx.json`.
Keep a cheap fast one and a strong expensive one side by side.
Switch with `Ctrl+N`.
Run the same project against different providers.

A new provider is a few lines of config, not a new tool:

```json
"providers": {
  "openrouter": {"type": "openai", "base_url": "https://openrouter.ai/api/v1", "api_key": "$OPENROUTER_API_KEY"}
},
"models": [
  {"id": "qwen/qwen3-coder", "provider": "openrouter", "context_window": 262144}
]
```

Save the config and restart EONYX.
The model is in the `Ctrl+N` list, with the same skills and hooks.
`Ctrl+N` switches between models already in the config, so a freshly added one needs that restart.

{{< admonition type="tip" title="Don't like the answer — change the model, not the tool" >}}
A strong new model appears at another provider.
Add a line to the config and keep working.
Same agent, same skills, same hooks.
Claude Code keeps you on the Claude lineup.
{{< /admonition >}}

### Local execution

Ollama, llama.cpp and LM Studio are supported.
So EONYX can run **entirely on a local model**, without sending your code to anyone's cloud.
Claude Code cannot: it always calls the Anthropic API.

This matters when:

- The code must not leave the perimeter, under an NDA, a closed network or regulation.
- The internet connection is unreliable.
- You want zero leak risk, because the data never leaves the machine.

Where your code goes in each case.

**EONYX: your choice**

```mermaid
sequenceDiagram
    participant U as Your code
    participant P as EONYX CLI
    participant L as Local model
    participant C as Cloud API
    U->>P: sources, configs, secrets
    alt by default
        P->>L: processed in place
        L-->>P: response
        Note over P,L: data does not leave the machine
    else only if you choose so
        P->>C: goes to the cloud
        C-->>P: response
    end
    P-->>U: result
```

**Claude Code: always the cloud**

```mermaid
sequenceDiagram
    participant U as Your code
    participant CC as Claude Code
    participant A as api.anthropic.com
    U->>CC: sources, configs, secrets
    CC->>A: always goes to the cloud
    A-->>CC: response
    CC-->>U: result
    Note over CC,A: no choice
```

{{< admonition type="note" title="One call still leaves the machine" >}}
Your code and the model traffic stay put.
The licence does not.
EONYX verifies it against eonyx.tech at every startup, so the machine has to reach that one host.
{{< /admonition >}}

### A single binary

- **Installation**
  - EONYX — a single static binary ([Go](https://go.dev))
  - Claude Code — [npm](https://www.npmjs.com) ([Node.js](https://nodejs.org) 18+) or an installer
- **Authorization**
  - EONYX — the provider's API key, and none at all for a local model
  - Claude Code — OAuth (Claude Pro/Max) or `ANTHROPIC_API_KEY`
- **Runtime**
  - EONYX — nothing extra, one process
  - Claude Code — Node.js

EONYX is **one process, with no telemetry and no OAuth**.
Download the binary, set a key or point it at a local model, and work.
Nothing to log into.

**From zero to the first prompt**

```bash
# EONYX
# 1. download the binary from the Releases page and put it in PATH
export DEEPSEEK_API_KEY=sk-...   # 2. a key — or a local model with no key
eonyx                             # 3. done, the TUI is open
```

```bash
# Claude Code
# 1. install Node.js 18+
npm install -g @anthropic-ai/claude-code   # 2. install the package
claude                                      # 3. OAuth login in the browser…
# 4. …a Pro/Max subscription or ANTHROPIC_API_KEY
# 5. only now — the first prompt
```

**3 steps against 5.**
And not one of the EONYX steps needs a browser, an account or a runtime.

### Shell in the process

The `bash` tool runs on the built-in [`mvdan.cc/sh`](https://github.com/mvdan/sh) interpreter.
**No system bash is needed.**
The same command behaves the same on Linux, macOS and **Windows without WSL**.
The working directory and the environment survive between calls.
A short list of dangerous commands is blocked at policy level: `shutdown`, `reboot`, `mkfs` and friends.

### Control over cost

- **Your own key, or a free local model.** DeepSeek costs pennies. A local model costs nothing. No product subscription required.
- **Transparent spend.** The TUI header shows input and output tokens, cached tokens and a dollar estimate as the session runs.
- **Your own limits.** `max_steps`, `context_window` and `retry` are tuned to your budget and your model.

What a month of work costs.
The Claude Pro subscription is the public price.
The API spend is an example and depends on the load.

{{< echarts height="18rem" >}}
{
  "color": ["#00ff41"],
  "tooltip": {},
  "xAxis": {
    "type": "category",
    "data": ["Local model", "DeepSeek via API (example)", "Claude Pro subscription"],
    "axisLabel": { "interval": 0 }
  },
  "yAxis": { "type": "value", "name": "$ / month" },
  "series": [{ "type": "bar", "barWidth": "45%", "data": [0, 3, 20] }]
}
{{< /echarts >}}

## ⚖️ The honest picture

### What you do not lose

EONYX is not a stripped-down clone.
The familiar toolset is all there:

- **MCP client** over stdio and HTTP, with resources and prompts.
- **Agent Skills** in `SKILL.md`, with progressive disclosure.
- **Hooks** around tools, `before` and `after`, context through `EONYX_*`.
- **Subagents** via the `task` tool, in an isolated context.
- **Sessions** in JSONL, with resume, fork and search.
- **Permissions** and **plan mode**, read-only until you approve the plan.
- **Auto-summarization** as the context window fills.
- **AGENTS.md** for standing project instructions across the tree.

Same workflow.
No provider lock-in.

### Where Claude Code is stronger

To keep this honest:

- **Claude models.** Opus and Sonnet are top-tier for code, and at Anthropic they come tuned for Claude Code out of the box.
- **Ecosystem and polish.** An official product: desktop and IDE apps, a web version, background tasks, support.
- **Zero provider setup.** Log in with a subscription and it works. No config to touch.

EONYX wins elsewhere: **freedom, locality, no lock-in**.
Want Claude models specifically and the smoothest official experience? Claude Code fits better.
Want one local binary, any provider including offline models, and full control over data and cost? Take EONYX.

## 📋 Summary

### Comparison table

| Capability     | EONYX                            | Claude Code               |
| -------------- | -------------------------------- | ------------------------- |
| Models         | <mark>any OpenAI-compatible API</mark>        | Claude only               |
| Local model    | <mark>yes: Ollama, llama.cpp, LM Studio</mark> | no, cloud only            |
| Installation   | <mark>a single binary (Go)</mark>             | Node.js 18+ / installer   |
| Authorization  | <mark>a key, or no key at all</mark>          | OAuth / Anthropic key     |
| Telemetry      | <mark>no</mark>                               | yes                       |
| Shell          | <mark>built-in (`mvdan/sh`)</mark>            | system                    |
| MCP            | yes                              | yes                       |
| Skills         | yes                              | yes                       |
| Hooks          | yes                              | yes                       |
| Subagents      | yes                              | yes                       |
| Plan mode      | yes                              | yes                       |
| Sessions       | yes                              | yes                       |
| Permissions    | yes                              | yes                       |
| Cost           | <mark>your own key / local for free</mark>    | subscription / Anthropic API |

{{< admonition type="abstract" title="Cheat sheet" >}}
- **Model freedom** — any OpenAI-compatible provider and local models.
- **Local execution** — your code never leaves the machine.
- **A single binary** — Go, no Node, no OAuth, no telemetry.
- **Shell in the process** — `mvdan/sh`, works on Windows without WSL.
- **Cost control** — your own key or free local models, spend is visible in the header.
- **Nothing lost** — MCP, skills, hooks, subagents, sessions, plan mode and permissions are all there.
{{< /admonition >}}