evocompiler.com

Doing it by hand

One command does all of this. It is written out here for a machine with no browser, for a pipeline, and for an agent doing the setup itself — not because the short way is missing anything.

Sign the machine in

evolve auth login

It opens this website and waits. Sign in here — or create an account — and confirm that the terminal may be authorised. Nothing is pasted: what comes back to your machine is a one-time code that is worthless to anyone else, because redeeming it needs a secret only the waiting command holds.

The address defaults to https://api.evocompiler.com and only needs naming if you are pointed somewhere else. On a machine you reach over SSH, add --no-browser and it gives you a code to carry back from a browser anywhere — it has to be asked for, because opening a local port succeeds on that machine too and nothing else can tell the difference.

Check it afterwards with evolve auth status. End it with evolve auth logout, which revokes the credential rather than only forgetting it, and leaves connected agents working.

Connect an agent

Your agent talks to one address over HTTP. Nothing runs on your machine for this and nothing listens on a port — connecting an agent is giving it a credential, not starting a server. 

evolve mcp connect

It mints a durable, revocable, account-bound credential and stores it where the operating system keeps secrets. It needs the machine to be signed in already, because the credential belongs to your account. Only a hash of it is kept here, so nobody, us included, can read it back to you; if you lose it, mint another and revoke the old one.

For a client that wants the header inline, evolve mcp headers prints it and nothing else. The configuration a client expects looks like this, with a real value where the dots are: 

{
  "mcpServers": {
    "evolve": {
      "type": "http",
      "url": "https://mcp.evocompiler.com/mcp",
      "headers": { "Authorization": "Bearer evomcp_..." }
    }
  }
}

Or, without editing a file: claude mcp add --transport http evolve https://mcp.evocompiler.com/mcp --header "Authorization: Bearer <your-connection>".

That credential connects an agent. It is not your sign-in. It will not authenticate the account API and it cannot close your account, so an agent configuration that leaks is an agent to revoke rather than an account to recover. See what is connected with evolve mcp connections, and disconnect one with evolve mcp revoke <id>.

Make a project

A project is a durable identity for a codebase, so what you tune survives changing machines. Every finished optimisation is saved as a version beside the last one, and they all show up on your projects page. 

evolve projects create my-firmware
evolve projects

The id it creates is bound into .evolve/ in the working directory and becomes the default for everything after it, so you do not have to carry it between commands. Your agent can make one too, through the same route; a project made either way is the same project.

Give your agent a machine to measure on

Your agent proposes settings; something has to build them and time them. That something is a target adapter — a small program of yours that knows how to build your code, run it, check it and report a number. It runs on your machine, never on ours. 

evolve setup measure

For the common case — measuring on the machine you are already sitting at — that scaffolds a host-local target and starts a runner. The four commands under it are the same thing without the shortcut, and are what you want when the target is not this machine: 

evolve region catalogue --compiler-family clang
evolve region target scaffold --adapter myboard --target-profile host-native       --hardware no --into adapters --write
evolve region target register --declaration declaration.json
evolve region runner serve --adapter myboard --device <device>

The catalogue is fetched first because it says which controls your compiler accepts and exactly what each one emits — a runner without it refuses, and says so. The scaffold writes a program that speaks the protocol correctly and measures nothing: the numbered steps in it are yours, and until you write them every run refuses rather than reporting a number nobody took. Then leave the runner going: while it is up, work your agent queues gets built, run and timed here, and the result comes back to your project.

Read the adapter before you register it. It is your program and it runs with your permissions; registering says this project may execute it. What the declaration checks is that it is coherent — not that it is safe. And an adapter with no correctness check in it measures whether the wrong answer arrives sooner, so put your own test there before you tune anything.

Using a compiler you already have

A compiler you have saved runs on your own machine with no account, no lookup and no network. Designing needs us; using what you designed does not.

Measuring on a board is not one of these commands. A hardware run is disclosed and prepared for you and then stops: you run it in your own terminal. The board must be completely disconnected from anything around it first. What that means and why.

Install Evo · For agents · How it works · Back