# Eva — An open-source autonomous software factory

> Eva is an open-source, autonomous software factory. It runs coding work end to end, from a spec a machine can check to evidence that it was done.

A local-first control center for coding agents. They run in parallel, and they ship without losing context.

## Install

Homebrew:

```sh
brew install --cask missingstudio/tap/eva
```

Script:

```sh
curl -fsSL https://raw.githubusercontent.com/missingstudio/eva/main/scripts/install.sh | sh
```

npm:

```sh
npm i -g @missingstudio/eva
```

Source:

```sh
git clone git@github.com:missingstudio/eva.git && bun install
```

Current version: 0.2.0. Every channel, and how to verify a download: https://docs.evafactory.co/install

## Interfaces and authentication

Eva is a command-line program that runs on your machine. There is no hosted HTTP API, no public base URL, and no account, so an agent does not obtain a credential from this site.

- Call it as a program. `eva -p "<prompt>"` answers once, prints to stdout, and exits 0 when the run ended done and 1 when it did not.
- Model credentials are your own, read from the environment, and never written to a config file, a log, or the session record. See https://docs.evafactory.co/connect-a-model.
- The full command surface and every exit code: https://docs.evafactory.co/reference/cli and https://docs.evafactory.co/reference/exit-codes.

## What Eva does today

- **Every capability is a plugin.** A small kernel loads plugins. The model, the surface, the trace, the themes — each one is a plugin, and any of them can be replaced or switched off. (https://docs.evafactory.co/extend/how-plugins-work)
- **A session survives kill -9.** Everything Eva shows is folded from a durable trace on disk. There is no in-memory state a crash could lose, because there is none that matters. (https://docs.evafactory.co/use/sessions)
- **You can see what a run cost.** Eva records what the provider said a request cost, in integer ticks. It marks an estimate as an estimate, and never multiplies tokens by a rate and calls it a cost. (https://docs.evafactory.co/use/cost)
- **A repository earns its trust.** Eva reads a project's .eva directory only after you run eva trust there. The grant is a verb you type, not a file a repository can ship. (https://docs.evafactory.co/configure/trust)

## When to use Eva

- You want to run a coding prompt from a script, a hook, or a CI job and branch on a real exit code, rather than parse a chat transcript. `eva -p` prints the answer to stdout and exits non-zero when the run fails.
- You want the work recorded. Eva folds everything it shows from a durable trace on disk, so a session survives `kill -9`, and it records what the provider said each request cost.
- You want to reach a coding model through one contract instead of one SDK per vendor. The provider is a plugin, and `--model provider/model` picks it per run.
- You want to add a capability — a model provider, a surface, a trace store, a tool — without forking. Every capability in Eva is already a plugin, and a plugin is loaded with `--plugin <id>`.
- You want a coding agent that reads a repository's configuration only after a person grants it. `eva trust` is a verb someone types; it is not a file a repository can ship.

## When not to use Eva

- You need a hosted API. Eva runs on your machine and serves no public HTTP endpoint. There is no key to obtain and no base URL to call.
- You need one spec raced across several harnesses, or unattended overnight runs. Both are on the roadmap and neither ships today.
- You need the work checked against acceptance criteria. Eva records an agent's claim as a claim, never as evidence. The verifier that decides whether work passed is a later stage.

## Local-first, and open

Your key never reaches a settings file, a log, or the session record.

Eva reads a repository’s configuration only after you grant it. Everything runs on your machine.

Eva is MIT licensed and the whole tree is public. Missing studio is the company behind it, and its first product is Eva as a managed service — the same tree, operated for you. Self-hosting is not a downgrade path.

## Questions

**What is an open-source autonomous software factory?**

A system that runs coding work from a spec a machine can check to evidence that it was done, with one contract over every harness, one trace of what they did, one verifier that decides whether the work passed, and one bill that prices it. Eva is an open-source implementation of that category.

**What is a coding agent harness?**

A harness is the thing that takes a prompt and drives it to a stopping point. Claude Code, Codex, and OpenCode are harnesses, and so is Eva's own loop. Eva drives harnesses rather than competing to be a better one.

**How do I verify a coding agent's work instead of trusting its claim?**

You have something other than the agent check it. Eva records the agent's claim as a claim, in the trace, and never as evidence. The verifier that checks acceptance criteria itself — and can score a diff produced by any harness — is stage 5 on the roadmap.

**Can Eva run coding agents in parallel, or overnight?**

Not yet. Racing one spec across harnesses in separate git worktrees is stage 9c, and unattended overnight work needs the queue and daemon at stage 9a. Durable sessions, which both depend on, ship today.

**What happens if Eva crashes in the middle of a task?**

Nothing is lost. Everything Eva shows is folded from a durable trace on disk, so a session survives kill -9. There is no in-memory state a crash could lose, because there is none that matters.

**Is Eva free and open source?**

Yes. Eva is MIT licensed and the whole tree is public. There is no paid tier that unlocks capability, and self-hosting is not a downgrade path.

**Do I need new API keys or another subscription?**

One Anthropic API key, set in your environment. Eva drives the harnesses you already pay for rather than reselling access to them.

**Where do my code and my key go?**

Nowhere. Eva runs on your machine. Your key is read from the environment and never reaches a settings file, a log, or the session record.

**How is this different from running Claude Code directly?**

Claude Code is a harness. Eva drives harnesses behind one contract, records everything in one trace, and attributes cost per task. Eva's own harness has no privileged position.

**What actually works today?**

A terminal client on a plugin kernel: one provider, one interactive surface, durable sessions, and cost accounting. The multi-harness contract and the verifier are on the roadmap.

## More

- Agent index: https://evafactory.co/llms.txt
- Documentation: https://docs.evafactory.co (markdown index at https://docs.evafactory.co/llms.txt)
- Pricing: https://evafactory.co/pricing.md
- Source, MIT licensed: https://github.com/missingstudio/eva
- Package: https://www.npmjs.com/package/@missingstudio/eva