Deep Axiom An open-source AI runtime for software that already exists
Every existing option is wrong in the same way
Workflow tools, agent frameworks, embeddable SDKs, voice frameworks, model marketplaces — each solved one piece. None of them led with "connect the software you already run."
Workflow Tools
n8n / Zapier / Make
Core paradigm
Batch triggers, outside your code
For developers
You hand-build every integration; nothing is real-time or edge-aware by design.
Legacy systems
Pokes the system from the outside — never touches the running application.
Execution model
Trigger & polling (passive)
Batch Automation
Deep Axiom
AURA Kernel
Core paradigm
Typed, causal, real-time streams
For developers ★ KEY
Write a ~30-line skill against the SDK; publish it to a federable registry others can install by capability.
Legacy systems
`aura connect --openapi` projects an existing API as skills in minutes — read-only by default, writes gated.
Execution model
Reactive streaming (WebSocket, back-pressured)
Clone it. Build it. Run it.
View on GitHubAny model, any device, one interface
Deep Axiom's kernel — built on the AURA architecture — is not for deploying one AI model; it's the runtime that unifies all your tools: legacy APIs, databases, edge devices, and AI models of every kind, into one coherent system that perceives, reasons, and acts in real time. This is possible because of one atomic unit: the Skill. There are five types:
Sensorial
Perceives — turns the world into data. ASR (speech-to-text), OCR, cameras, file readers, or a projected read-only endpoint from an existing API.
Motor
Acts — produces effects in the world. Sends a message, writes to an ERP, speaks out loud. Every edge into a motor skill can carry a human-approval gate — the kernel holds the message until a person says yes.
Cognitive
Reasons — decides, plans, generates. Any LLM behind one interface: a local GGUF via llama.cpp with no account and no cloud, or any OpenAI-compatible API (OpenAI, Gemini) if you'd rather use a cloud model.
Logical
Transforms and validates — deterministic data-to-data. Parsers, validators, format bridges: the plumbing that turns one skill's output into the next skill's input.
Memory
Remembers — persists and retrieves context. Per-session conversation history today; durable, queryable memory as the architecture matures.
How it composes
With this palette of five skill types, everything else — from a two-line test graph to a gated multi-agent pipeline — is built on three concepts:
Skill
The atomic, reusable unit.
A Skill is something the system knows how to do: identity, typed ports, a manifest. It can be logic, a model, or a projection of a system you already run — connected to the kernel, never rewritten.
Graph
Skills wired by typed channels.
A human writes a graph in a few lines of JSON, or a planner generates one from a natural-language goal — both compile to the exact same intermediate representation and run through the same executor. One debugger, one permission model, one replay path.
Session
A live, causal, explainable run.
Every session persists an append-only causal event log — each message names the message that caused it. `aura why` narrates a failure's root cause from that log; `aura replay` turns recorded traffic into an eval suite.
What the runtime actually does
Four commitments the whole design falls out of.
Legacy-first
The first useful command is not "create a project" — it's "connect what you already have." Point it at an OpenAPI spec and its operations become skills, read-only by default, writes gated behind human approval.
Real-time by default
The unit of communication is a typed, causal, back-pressured stream, not a function call. Text streams token by token; the same primitive carries audio and events.
Any model, any device
LLMs, ASR, OCR, TTS, embeddings — all live behind one interface, local or remote. The same logical graph runs on a laptop or spreads across a fleet by changing only where skills are placed.
Owned by everyone
The spec, kernel, and SDKs are neutral and open forever; the registry is federable, so no single party controls distribution. Forking the standard is always trivial — that's what makes the neutrality credible.
Runnable today, not a roadmap slide
Every example below is real code in the repository. Clone it, build the kernel, and run it — no account required.
Worked examples
FLAGSHIP EXAMPLE
Gated multi-agent back office
Three skills — researcher, writer, approver — chained in a declared graph. The delivery step carries a real human-approval gate: deny it, and nothing is written to disk. `aura why` narrates the causal chain either way.
REAL-TIME
Speech in, reasoning, speech out
ASR → LLM → TTS wired into one graph. A spoken sentence comes back spoken, streaming the whole way, local models only — no cloud, no account.
LEGACY-FIRST
An existing API, AI-operable in minutes
`aura connect --openapi` turns a real OpenAPI spec into skills. Reads go live immediately; every write starts disabled until you promote it, and even then a human approves it.
EDGE + CLOUD
One command, work runs on another machine
Federate a node and it starts resolving capabilities that physically live elsewhere — replies stream back with causality intact. Zero kernel changes were needed to build it.
Two ways in: write or install
The SDK for people who build skills, the marketplace for everyone who wants to use them without writing code.
The SDK
A skill is a directory: a manifest, code, dependencies. The Python SDK handles connection, causality, and idempotency — a working skill is about 30 lines.
The Marketplace
`aura publish` signs and uploads a skill to a federable registry; `aura add --capability` installs by function, not by name. Anyone can host a registry — it's not a platform you're locked into.
Security is progressive, not bolted on
Zero friction on localhost — no account, no signing, nothing to configure. Signing, declared permissions, and sandboxing switch on only when you publish or federate. Every action a skill can take is gated for human approval by policy that lives in code, not in a prompt.
The principles the design doesn't bend on
Eight commitments that hold across every feature in the runtime — not slogans, the actual constraints the kernel enforces.
Legacy-first
Connecting what already exists is the first command, not an afterthought bolted on later.
Real-time by default
Every channel is a typed, causal, back-pressured stream — not a request/response call pretending to be one.
Any model, any device
One interface for local and cloud models alike; the same graph runs on a laptop or across a fleet.
Owned by everyone
The spec, kernel, and SDKs stay neutral and open; the registry is federable so no party controls distribution.
Progressive security
Zero friction on localhost; signing, permissions, and sandboxing switch on only at the point real risk appears.
Capability-based permissions
Anything a skill's manifest doesn't declare, it cannot do. Nothing is granted by default.
Human-in-the-loop for actions
Every edge into a skill that acts on the world can hold for approval — the safety rule lives in the graph, not a prompt.
Causal auditability
Every session is an append-only causal log. `aura why` explains it; `aura replay` turns it into a regression test.
Clone it. Build it. Run it today.
Deep Axiom is open source and available now — no waitlist, no account. Ten minutes from a cold clone to a gated multi-agent pipeline running on your own machine.