v0.3.0 · free & open source

AI that acts in real time. And proves it.

AURA runs your agents and automations live over the systems you already have, stops for a human before anything touches the world, and seals every action into a ledger anyone can verify — offline, without trusting us.

Get it free View on GitHub

60 s: from download to a running node
1 binary: 18.6 MB · no cloud, no database, no account
5.5×: more throughput at 200 live sessions

Why teams pick it

Three things no workflow tool or agent framework gives you

Live, not batch

The connection is the unit of work. Sources push, models stream token by token, and a dropped socket resumes where it was.
→
Provable, not logged

A human-approval gate the kernel enforces, and a hash-chained ledger that verifies with the node switched off. Evidence for EU AI Act Art. 12/14 and ISO/IEC 42001.
→
Yours, not rented

One binary on your machine. Spec and SDKs Apache-2.0 forever, a registry you can host, and forking always trivial.
→

Get it

Free, signed, and running in a minute

Linux, macOS and Windows on amd64 and arm64. Checksums and SBOM signed with cosign. No account, no cloud, nothing to sign up for.

Download Docker From source

Download and verify

Check the signature on SHA256SUMS first — it proves who built the file — then the sum. Two commands, then aura up.

1 · aura up — kernel, UI, store, ledger and witness client, one process.
2 · cd skills/echo && PYTHONPATH=../../sdk/python/src python main.py — a skill connects.
3 · aura chat --graph echo "hello aura" — every envelope logged before it was acknowledged.

Open the release → How verification works → Full quick start →

bash

$ curl -LO https://github.com/DeepAxiom/deepaxiom_aura/releases/download/v0.3.0/aura-linux-amd64 && curl -LO https://github.com/DeepAxiom/deepaxiom_aura/releases/download/v0.3.0/SHA256SUMS{,.sig,.pem}
$ cosign verify-blob --certificate-identity-regexp "^https://github.com/DeepAxiom/deepaxiom_aura/.github/workflows/release.yml@.*$" \
    --certificate-oidc-issuer https://token.actions.githubusercontent.com --signature SHA256SUMS.sig --certificate SHA256SUMS.pem SHA256SUMS
Verified OK
$ sha256sum -c SHA256SUMS --ignore-missing && chmod +x aura-linux-amd64 && ./aura-linux-amd64 up
  aura 0.3.0 — kernel up   ui http://localhost:9080

As a service

One kernel, a persistent volume, a deny-by-default policy. Distroless, non-root, drains on SIGTERM. Built from the repo until the image is published.

1 · aura up — kernel, UI, store, ledger and witness client, one process.
2 · cd skills/echo && PYTHONPATH=../../sdk/python/src python main.py — a skill connects.
3 · aura chat --graph echo "hello aura" — every envelope logged before it was acknowledged.

Open the release → How verification works → Full quick start →

bash

$ git clone https://github.com/DeepAxiom/deepaxiom_aura && cd deepaxiom_aura
$ docker compose up      # kernel + persistent volume + deploy/aura.policy.yaml

Build it yourself

Go 1.25+, no CGO, no external services.

1 · aura up — kernel, UI, store, ledger and witness client, one process.
2 · cd skills/echo && PYTHONPATH=../../sdk/python/src python main.py — a skill connects.
3 · aura chat --graph echo "hello aura" — every envelope logged before it was acknowledged.

Open the release → How verification works → Full quick start →

bash

$ git clone https://github.com/DeepAxiom/deepaxiom_aura && cd deepaxiom_aura/kernel
$ go build -o aura ./cmd/aura && ./aura up

Figure 1

From download to a running node, and where skills come from

One signed binary from GitHub. Skills are processes that connect to it. The public registry and Studio share a VPS; Studio only ever reads the registry over HTTP.

registry.deepaxiom.com

Public registry — live

aura add installs from registry.deepaxiom.com after verifying hash and signature. Publishing needs a publisher credential (issued on request) because the first key to publish an id owns it forever.

studio.deepaxiom.com

DeepAxiom Studio — live

Browse the registry, download a version, see who builds what, and draw C2 graphs on a canvas — export the exact IR a node registers.

Open Studio

Real time

Built for work that is alive

A conversation, a video feed, a database changing under you, a model answering token by token. Batch tools fire once and finish; AURA keeps the connection open.

Figure 2

The source pushes. The model streams. Downstream reacts mid-sentence.

Only the edge that acts on the world is gated, and only that delivery is sealed. Everything else is just fast.

1,908 msg/s: at 200 concurrent sessions — up from 344, same durability
63 ms: p50 at 200 sessions — down from 489 ms
1.5M ev/s: append-only event log vs 27k in SQLite

Echo skill over loopback: the kernel's own routing and durability cost. kernel/cmd/loadgen/ reproduces it.

QUIC on the same port as TCP: realtime datagrams, reliable ordered streams, bulk on its own lane. A lost packet stalls only its lane. Cancelling is a kernel guarantee.

Start without adopting anything

Already running an agent with MCP servers? Guard it in one command.

No runtime to stand up, no rewrite, no SDK. Tools are gated unless their server proves they only read — and you chose to believe it.

your terminal

$ aura guard --config claude_desktop_config.json
  no node on port 9080 — running an embedded kernel
  TOOL               CAPABILITY                   ON CALL
  probe/read_thing   motor.mcp.probe.read_thing   human approval + sealed
  probe/write_thing  motor.mcp.probe.write_thing  human approval + sealed
  2 of 2 act on the world and are gated; the rest are read-only.

Figure 3

Your agent, unchanged. One checkpoint in the path.

Every tool call passes a policy you control, stops for a human if it acts on the world, and comes back with a receipt.

Honest limit: this holds as far as your control over the agent's config does. There is no network-level enforcement. How guard works →

Provable

An audit trail as a property of execution — not a log beside it

Frameworks log what you remembered to log. AURA seals evidence at the one point every delivery passes through, so it still answers six months later.

Figure 4

Every delivery crosses this one point

The kernel applies it, not your code. A refusal is sealed too: an auditor asks what was attempted, not only what succeeded.

Figure 5

Edit one entry and every hash after it breaks

Each entry commits to the previous one; a signed Merkle head commits to all of them. `aura verify` recomputes it from the file alone — no node, no trust in us.

Gate as a kernel invariant
Approver signs, Ed25519, key the node never held
RFC 6962 Merkle head, witness-countersignable
Scoped skill credentials, deny by default
Secrets released only against a receipt
Model, revision, seed bound into every effect

aura verify · audit · why · replay · regress · bundle · bom · undo

Specified, not invented

EU AI Act Articles 12 (record-keeping) and 14 (human oversight) apply to high-risk systems from 2 December 2027. ISO/IEC 42001 clause 9.2 wants the same evidence chain and is in force today. AURA emits the records; the conformity assessment stays yours.

C4 — Effect Ledger & Policy → Internet-Draft →

How it works

Five frozen contracts. Any kernel can implement them.

Versioned, additive-only, with a 59-check conformance suite. Neutrality you can check, not a promise.

Figure 6

One kernel, five kinds of skill, one session

Sensorial perceives, cognitive reasons, memory remembers, motor acts — behind a gate. The causal log records the rest so `aura why` can tell the story.

C1 Manifest — what a skill is
C2 Graph IR — how skills wire
C3 Channel — the typed, causal envelope
C4 Ledger & Policy — what acted, approved by whom
C5 Attestation — which model, bound to the effect
Read the contracts →

Beside your app in six lines

write: true is the only line about safety — and it is enough: the kernel gates that call on every edge and seals the effect. CI proves it against a real binary on every push.

MCP both ways · OpenAPI → skills · OpenTelemetry · A2A · webhooks · federation

examples/expose-app

app.mjs

import { createNode } from "@deepaxiom/aura";
const aura = createNode({ org: "acme", app: "shop" });
aura.expose("get-order",    ({id}) => db.orders.find(id),   { params: ["id"] });
aura.expose("refund-order", ({id}) => db.orders.refund(id), { params: ["id"], write: true });
await aura.start();
// write:true → motor capability → gated on every edge → sealed

Compare

Pick this one when you have to answer for what the agent did

Workflow tools

n8n · Zapier · Make

Agent frameworks

LangGraph · CrewAI · AutoGen

AURA

free · open source

Execution

Trigger, run, tear down

A loop in your process

A live, streaming connection

Approval gate

A step you remember to add

Code you wrote — or forgot

A kernel invariant

Evidence

Vendor console logs

Traces, not tamper-evident

Hash-chained, signed, verifiable offline

Who approved

A user id in a row

Usually nothing

An Ed25519 signature the node cannot forge

Where it runs

Mostly SaaS

Your process to operate

One 18.6 MB binary, anywhere

Execution

Workflow tools: Trigger, run, tear down
Agent frameworks: A loop in your process
AURA: A live, streaming connection

Approval gate

Workflow tools: A step you remember to add
Agent frameworks: Code you wrote — or forgot
AURA: A kernel invariant

Evidence

Workflow tools: Vendor console logs
Agent frameworks: Traces, not tamper-evident
AURA: Hash-chained, signed, verifiable offline

Who approved

Workflow tools: A user id in a row
Agent frameworks: Usually nothing
AURA: An Ed25519 signature the node cannot forge

Where it runs

Workflow tools: Mostly SaaS
Agent frameworks: Your process to operate
AURA: One 18.6 MB binary, anywhere

A comparison of designs, not a benchmark. Frameworks have a far larger tool ecosystem and years of maturity.

Ecosystem

Build a skill in 100 lines. Publish it. Keep the rights.

Figure 7

Publish once, install anywhere

Immutable versions, publisher key bound to the id on first publish, hash and signature verified before install. Studio is the web front for it.

SDKs in Python and Node

Connection, causality, idempotency and credentials handled. Start from skills/echo/. Apache-2.0: a skill you sell carries no copyleft, ever.

SDK guide

Studio

The registry's web front: browse, download, developer directory, and a graph canvas that exports spec-pure C2. Accounts and publishing from the browser are next.

Open Studio

Until the microVM sandbox lands, format: source skills are not contained — publish and host your own rather than install strangers' code. format: wasm is genuinely sandboxed.

Services

Don't want to build it yourself? We build it on AURA for you.

Deep Axiom is the team behind the runtime. We take your requirements from discovery to production: the software, the AI inside it, and the evidence trail that lets you answer for what it did.

Enterprise web platforms

CRM, ERP, billing, back-office — the systems your business runs on, with AI that acts inside them under a human gate.
Logistics & tracking

Fleets, routes, sensors, live positions. Real-time by construction: the source pushes, the map moves.
Native mobile apps

iOS and Android, voice and camera as first-class inputs, offline-tolerant, with the same audited backend.
Social & community products

Feeds, messaging, moderation with a person deciding behind the model — drafted by AI, signed by a human.
Cybersecurity & compliance

Every action gated, attested and verifiable offline. Evidence built for EU AI Act, ISO/IEC 42001 and your auditor.
AI over what you already run

Point AURA at your OpenAPI spec or database and its operations become skills — read-only by default, writes behind approval.

Why AURA makes it possible

One runtime carries text, voice, documents and events as the same typed stream; every integration is a skill you can reuse; every write is gated and sealed. That is why a CRM, a tracking app and a chat assistant come out of the same kernel — and why what we ship for you can be audited by someone who was not in the room.

A team of engineers who wrote the kernel, the SDKs and the spec — in Puebla, México, working worldwide.

Tell us what you need

A first conversation is free, and so is the runtime.

Where it honestly stands

Pre-1.0 — and the gaps are listed, not hidden

Tested in CI

Streaming over WebSocket and QUIC · ledger and offline verification · the gate · signed approvals · scoped credentials · witness · resume · replay · regression · MCP both ways · guard · Wasm sandbox · Postgres CDC · backup/restore · key rotation.

Hand-verified

Voice with barge-in · the planner · aura why · OpenTelemetry · ML-BOM.

Not yet

No failover (one process; a restart rebuilds state) · SDKs not on npm/PyPI · container image not published · no microVM for source skills · no public witness.

Full roadmap

Questions

Frequently asked

Is it really free?

Yes. Spec and SDKs are Apache-2.0 forever; kernel and UI are AGPL-3.0-or-later, which only triggers if you offer a modified kernel to others over a network. Running it inside your organisation obliges nothing. A commercial licence exists for anyone who wants different terms.

How is this different from LangGraph, CrewAI or AutoGen?

Those are libraries you build a loop with, inside your process. AURA is a runtime your skills connect to: the approval gate is applied by the executor where every delivery passes, under a policy a graph cannot weaken, and the record it leaves is signed and hash-chained rather than a trace.

Does this make me EU AI Act compliant?

It produces the evidence Articles 12 and 14 ask for — automatic event recording and oversight by an identifiable person. It does not perform the conformity assessment; no tool can. ISO/IEC 42001 clause 9.2 wants a comparable chain and is in force today.

Is it production-ready?

Pre-1.0. The blocking gap is failover: one process, and if it dies live routing state goes with it (the event log survives and a restart rebuilds it). If your app degrades when AURA falls over, deploy it today as an auxiliary service; if it stops, read the roadmap first.

Do I need an account, cloud or API key?

No. One binary, nothing phones home. Models can be local GGUF files or any OpenAI-compatible endpoint.

Where do skills come from, and what is Studio?

The public registry at registry.deepaxiom.com is live: `aura add` installs after verifying hash and signature; publishing needs a publisher credential because the first key to publish an id owns it. Studio at studio.deepaxiom.com is the web front — browse, download, a developer directory and a graph canvas.

Sixty seconds

Download it. Verify it. Run it today.

Free, open source, one binary. No account, no waitlist, nothing to sign up for.

bash

$ curl -LO https://github.com/DeepAxiom/deepaxiom_aura/releases/download/v0.3.0/aura-linux-amd64
$ sha256sum -c SHA256SUMS --ignore-missing   # after cosign verify-blob — see #install
$ chmod +x aura-linux-amd64 && ./aura-linux-amd64 up

  aura 0.3.0 — kernel up
  ui        http://localhost:9080
  ledger    0 effect(s) sealed · 0 checkpoint(s)

Get v0.3.0 free Read the quick start

Follow the work

AI that acts in real time. And proves it.

Three things no workflow tool or agent framework gives you

Live, not batch

Provable, not logged

Yours, not rented

Free, signed, and running in a minute

Download and verify

As a service

Build it yourself

From download to a running node, and where skills come from

Public registry — live

DeepAxiom Studio — live

Built for work that is alive

The source pushes. The model streams. Downstream reacts mid-sentence.

Already running an agent with MCP servers? Guard it in one command.

Your agent, unchanged. One checkpoint in the path.

An audit trail as a property of execution — not a log beside it

Every delivery crosses this one point

Edit one entry and every hash after it breaks

Five frozen contracts. Any kernel can implement them.

One kernel, five kinds of skill, one session

Beside your app in six lines

Pick this one when you have to answer for what the agent did

Workflow tools

Agent frameworks

AURA

Execution

Approval gate

Evidence

Who approved

Where it runs

Build a skill in 100 lines. Publish it. Keep the rights.

Publish once, install anywhere

SDKs in Python and Node

Studio

Don't want to build it yourself? We build it on AURA for you.

Enterprise web platforms

Logistics & tracking

Native mobile apps

Social & community products

Cybersecurity & compliance

AI over what you already run

Why AURA makes it possible

Pre-1.0 — and the gaps are listed, not hidden

Tested in CI

Hand-verified

Not yet

Frequently asked

Is it really free?

How is this different from LangGraph, CrewAI or AutoGen?

Does this make me EU AI Act compliant?

Is it production-ready?

Do I need an account, cloud or API key?

Where do skills come from, and what is Studio?

Download it. Verify it. Run it today.