Open source · Agent Execution Protocol
An open runtime for
agents that show their work.
A wire protocol anyone can implement, and the reference runtime behind it. Every tick — the reasoning, the tool call, the result — is written as it happens.
Open protocol. One wire format to start, observe, hold, and replay an agent run.
A format anyone can implement, so the record of a run outlives the system that produced it.
npm install @helixsdk/corepip install helix-protocolObserve every tick
Reasoning, tool call, arguments, result — written while the run is still going, not assembled from logs afterwards.
Hold what needs a human
Irreversible actions queue instead of firing, addressed to a named reviewer, with the wait recorded as a step.
Replay from the record
The timeline and the event stream are the same data, so any client can reconstruct the run exactly as it ran.
Open source stewardship
Development, issues and decisions happen in the open, in the repository.
The runtime that implements the protocol.
One Next.js application serving AEP at /aep/v1 and shipping the product around it — authoring, run history, reviews, artifacts.
Start a run
Create an agent, hand it a goal, and get a run id back. Capabilities are agreed in the same handshake.
Stream the events
Subscribe over server-sent events and read each tick as the runtime writes it.
Hold an action
Anything irreversible queues for a named reviewer instead of firing, and the wait is on the record.
Collect artifacts
Whatever the run produced is addressable afterwards, alongside the steps that produced it.
An agent run is not a black box. It is a sequence of ticks you can read.
Each tick writes its own steps as it goes. The record is an output of the run, so there is nothing to reconstruct afterwards.
The tick loop
Four things happen in a tick, and all four are written down before the next one starts.
One runOne runadvances in ticks
- Reason01
What the model worked out this tick, in its own words.
- Tool call02
The call it chose and the arguments it passed.
- Result03
What came back, and what it kept or dropped.
- Hold04
An action it will not take alone. Queued for a reviewer.
Written as it happens · never reconstructed
The event stream
Subscribe to /aep/v1/runs/{id}/events and read the run live. The interface draws the same stream.
GET /aep/v1/runs/{id}/events- 00.00tick 1reasonedNeeds current filings before it can answer
plan: fetch → compare → draft
- 00.42tick 2tool_callfilings.search
{ "issuer": "reliance", "period": "FY24" }
- 01.10tick 2result3 documents returned
2 kept · 1 dropped (superseded)
- 01.88tick 3reasonedDraft asserts a figure the filings contest
confidence below the send threshold
- 02.31tick 4heldemail.send — held for review
queued, unsent · routed to the named reviewer
- —on approvalartifactArtifact written, run closed
every step above replays from the same stream
The repository
One Next.js application. The protocol, the product and the durable work each in a directory you can open.
evigauge-org/helix- app/aep/v1JSON-RPC over HTTP, SSE streams, artifacts
- app/(authenticated)agents, runs, reviews, analytics, integrations
- app/apichat, artifacts, research, store builder, auth
- libagents, memory, research, presentations, crypto
- inngestdurable execution and scheduled work
- prismaPostgres structure and migrations
- docswhitepaper, API reference, ADRs
It runs on its own. It stops before it does something it cannot undo.
Irreversible actions queue instead of firing. A named reviewer releases them, and the wait is on the record like any other step.
The agent drafts
tick 4Composed, with the reasoning already on the record.
The run stops itself
heldQueued and unsent, routed to a named reviewer.
A person releases it
releasedApproval resumes the same run. One history, not two.
run_8fa2 · awaiting reviewemail.send
The draft is written and queued. It does not leave until the named reviewer says so.
- to
- investors@—
- reason
- asserted figure contested by a cited filing
- reviewer
- assigned · notified
- state
- queued, unsent
Two parts. One protocol.
The runtime is source-available. The clients are Apache-2.0 and talk to any AEP implementation, including one you write yourself.
Fair Source 1.0
Helix runtime
The reference implementation of AEP. A Next.js application that serves the protocol and ships the product around it — authoring, run history, reviews, artifacts.
git clone github.com/evigauge-org/helix- Serves the wire protocol at /aep/v1
- Agent authoring and run history
- Reviews, holds, and artifacts
- Postgres for state, Inngest for durable work
- Self-host it — free under $1M revenue
Apache-2.0
Client SDKs
TypeScript and Python clients for talking to any AEP runtime, not only this one. Separately licensed, with no revenue condition attached.
npm install @helixsdk/core- @helixsdk/core on npm
- helix-protocol on PyPI, imported as helix_sdk
- Version negotiation and capability agreement
- Async iteration over the run's event stream
- Talks to any AEP runtime, not only this one
How they fit together. One threshold, annual revenue.
The runtime is free under US$1M and licensed above it. The clients carry no revenue condition at all. Everything else is the same on both sides.
| Under US$1MFree | At or above US$1MCommercial licence | |
|---|---|---|
| Who | Organisations under US$1M annual revenue | Organisations at or above US$1M |
| Cost | Free, commercial use included | Commercial licence, arranged with us |
| Academic | Universities and non-profit research exempt at any size | Exempt — the threshold does not apply |
| Build on it | Services built on Helix are yours to sell | Services built on Helix are yours to sell |
| Redistribute | Not as a standalone product | Not as a standalone product |
| Client SDKs | Apache-2.0, no revenue condition | Apache-2.0, no revenue condition |
AEP is meant to have more than one implementation.
If you are writing one, the whitepaper and the architecture decision records are the place to start.
Building on AEP? Tell us what you are making.
Helix is the reference implementation, not the only one. Clone it, read the protocol, or get in touch about a commercial licence.