# EONYX vs Claude Code: an honest comparison


**EONYX** and **[Claude Code](https://www.anthropic.com/claude-code)** are both terminal AI agents for working with code, and their workflow is similar: [MCP](https://modelcontextprotocol.io), skills, hooks, subagents, plan mode, sessions. The difference is in the architecture and the freedom. Claude Code is tied to the cloud and to [Anthropic](https://www.anthropic.com) models; EONYX is not. Here is what that gives you in practice.

<!--more-->

## How EONYX is different

Five practical differences — all of them follow from a single decision: not to be tied to a cloud or a vendor.

### Model freedom

Claude Code only works with Claude models (Anthropic). EONYX connects directly to **any OpenAI-compatible API** and is not tied to a single vendor:

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

A model is just an entry in `eonyx.json`. You can keep a cheap fast model and a powerful expensive one side by side, switch on the fly (`Ctrl+N`), and run the same project on different providers.

A new provider is a few lines of config, not a change of 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, restart EONYX — and the new model is already in the `Ctrl+N` list: the same agent, the same skills and hooks. `Ctrl+N` switches between models that are already in the config; to pick up one you have just added, the TUI has to be restarted.

{{< admonition type="tip" title="Don't like the answer — change the model, not the tool" >}}
A new strong model showed up at another provider? Add a line to the config — and you work with it using the same agent, the same skills and hooks. In Claude Code you are tied to the Claude lineup.
{{< /admonition >}}

### Local and offline

Since Ollama / llama.cpp / LM Studio are supported, EONYX can run **entirely on a local model** — with no internet and without sending your code to someone else's cloud. Claude Code cannot do that: it always goes to the Anthropic API.

This matters when:

- the code must not leave the perimeter (NDA, closed network, regulation);
- there is no stable internet connection;
- you need zero leak risk — the data does not leave the machine.

Where your code goes in each case.

**EONYX: your choice**

```mermaid
sequenceDiagram
    participant U as Your code
    participant P as EONYX Terminal
    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
```

### 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, for local models — no key at all
  - Claude Code — OAuth (Claude Pro/Max) or `ANTHROPIC_API_KEY`
- **Runtime**
  - EONYX — nothing extra, a single process
  - Claude Code — Node.js

EONYX is **one process with no external services, no telemetry and no OAuth**. Download the binary, set a key (or point it at a local model) — and you are working. Nothing to log into, nothing that "phones home".

**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
```

Bottom line: **3 steps against 5**, and not one of the EONYX steps requires a browser, an account or a runtime.

### Shell in the process

The `bash` tool in EONYX works through the built-in [`mvdan.cc/sh`](https://github.com/mvdan/sh) interpreter — **a system bash is not needed**. The same command runs identically on Linux, macOS and **Windows without WSL**. The working directory and environment variables are preserved between calls. A small list of dangerous commands (`shutdown`, `reboot`, `mkfs`…) is blocked at the policy level.

### Control over cost

- **Your own key or free local models.** You can run DeepSeek for pennies, or a local model for free. No subscription to a particular product is required.
- **Transparent costs.** The TUI header shows the number of input/output tokens, cached tokens and a cost estimate in dollars right as the session goes.
- **Your own limits.** `max_steps`, `context_window`, `retry` — everything is 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": ["#c15933"],
  "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 stays with you after the switch, and where Claude Code is still stronger.

### What you do not lose

EONYX is not a "stripped-down clone". The whole familiar agent toolset is there:

- **MCP client** (stdio and HTTP) — external services, resources and prompts;
- **Agent Skills** — skills in `SKILL.md` with progressive disclosure;
- **Hooks** around tools (`before`/`after`, context via `EONYX_*`);
- **Subagents** — the `task` tool with an isolated context;
- **Sessions** in JSONL with resume, fork and search;
- **Permissions** and **plan mode** (`/plan`) — read-only until you approve the plan;
- **Auto-summarization** of history when the context window fills up;
- **AGENTS.md** — persistent project instructions across the directory tree.

In other words, you get the same workflow, but **provider-independent**.

### Where Claude Code is stronger

To keep the comparison honest:

- **Claude models.** Opus/Sonnet are top-tier models for code; at Anthropic they come out of the box and are tuned for Claude Code.
- **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 everything works, no need to touch a config.

EONYX wins on other things: **freedom, locality and no lock-in**. If what you need is Claude models specifically and the smoothest possible official experience — Claude Code is the better fit. If you need a single local binary, any provider (including offline models) and full control over data and cost — EONYX.

## Summary

### Comparison table

| Capability     | EONYX                            | Claude Code               |
| -------------- | -------------------------------- | ------------------------- |
| Models         | <mark>any OpenAI-compatible API</mark>        | Claude only               |
| Offline run    | <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 and offline** — the code does not leave the machine.
- **A single binary** — Go, no Node, no OAuth, no telemetry and no external services.
- **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 >}}