Aura | AI Coding Agent Runtime

Choose the audience that matches your question

The page contains three selectable readings of the same subject.

    return Err(SessionExpired);

The assistant, the search, the memory and the audit log folded into one binary.

Bug hunts, boilerplate, refactors and onboarding spread across seven tools.

Of course. Here is what I would like to do.

Can you help me fix this little mistake in my code?

the first test fails, Verify returns to Plan

the second patch passes, the goal closes

each posture shows its model and its outbound boundary

the final state reads goal satisfied, each criterion green

the cards become one loop state inside Aura

the loop remains central while the estate surrounds it

tool, policy, quality, memory, and audit nodes do not move

file claims prevent two agents from editing the same path

compile passes, tests fail, repair, tests pass, audit completes

verify-audit checks the chain at completion

one instruction changes the next tool call without a reset

the next call targets the failing test first

the loop holds before the next tool call

the session ends and the work is preserved

the last checkpoint is restored in place

optional providers and tools stay external where selected

each layer shows a concrete control and its result

built-in, MCP, and extension tools join at the same ingress

scope, permission, shell analysis, checkpoint, sanitise, audit

one failed test returns to the loop, then passes

it stops when the goal is met, when you stop it, or when it cannot go on honestly

Fix the login, add a test, explain this part. No commands to memorise.

It looks at your own files and notes, not a generic example.

A small target it can check when the work is done.

The exact file and line behind its plan.

It keeps to your project unless you allow more.

It picks a fit and falls back if one is away.

the conversation expands into a loop that keeps working toward the goal

let me look, change it, then check it holds

a visible forget action removes it whenever you want

a helper on your computer keeps the thinking with you, a cloud helper receives what you send

file claims mean two sessions do not silently edit the same path

access stays inside the project unless you allow more

each request becomes a small goal card, not a chat answer

Each request becomes a goal Aura can check

each step shows progress and the plan can change

it points to the exact files that shaped the plan

the audit chain can be verified later to detect modification

the context stays warm, so you do not re-explain the project

checkpoints are captured before supported file edits

your files, changes, checks, and record stay in one place

a provider-boundary marker shows where hidden internals stop

the router selects the cheapest configured model that meets the capability need

tokens, operators, quoting, and escaping are evaluated before execution

Structure decides, not a list of strings.

a deployment profile selects a set without changing the loop contract

The petals vary, the loop contract holds.

checkpoints undo live, worktrees isolate, Git is durable history

a cache entry invalidates after a patch touches its files

measured size and source-count figures belong in a revalidated build card

a live diff shows which layer supplied each effective value

the working set stays bounded rather than growing without limit

an event enters the bus and fans out by type name

the tree opens into an effective agent definition and a workflow DAG

the deterministic lane runs first, the model lane only when needed

the model lane runs only when the deterministic lane cannot decide

one repeated grep sequence triggers a corrective hint

you have run grep five times, try reading the file

a steering message between two actions changes the second

the active state reads test failed, replan 2, goal 3 of 4

the remote server behaviour remains an external boundary

deterministic relevance and BitRank over a bounded index, FTS5 fallback

two agents contend for one file and one claim is deferred

a tool result invalidates the plan without discarding the objective

The objective persists while the plan revises.

the model never receives the raw external content

an out-of-scope path is routed to approval, not silently widened

both invoke the same goal and quality policy and produce comparable events

modules are separated by typed contracts, not shared mutable state

the pending step is replaced and the audit records the event

a patch call and an MCP call each run the full pipeline

each panel maps to a loop responsibility

Coding agent and operator assistance. Demo metrics are illustrative.

Terminal, search, lint, test, git, and more.

Remembers your codebase and team context.

Specialised agents collaborate across concerns.

Review diffs, request changes, final sign-off.

Replay any session bit-for-bit when something needs review.

Autonomous agents that write code and keep receipts

to handle network timeouts, 5xx responses, and idempotent-safe conditions. Pure helper, fully unit-tested.

Aura ships as a single static binary with no runtime dependencies. Enterprise support, custom development, and training available from Dweve.

# resolved at runtime; AURA_MODEL overrides project

Anything you can set in TOML, model, per-tool permission levels, audit log path, named profile, you can pin per project, override per machine, or flip per env var. Touch any of those files, the agent watches them and rebuilds its system prompt without restarting the session. No reboot, no lost context.

Aura resolves config across four layers, built-in defaults, your user-level `~/.dweve/config.toml`, the project's `.aura/config.toml`, and any `AURA_*` environment variable. They merge per key, with each layer overriding the one beneath it; environment variables sit on top so a single export can flip Aura's behaviour for one CI job, one branch, one demo.

You read diffs against the project spec…

List or switch agents, project / user / builtin

Agents, skills, plugins and workflows are markdown + YAML on disk. Six built-in agents ship with Aura; project, user and global tiers are merged at startup. Edit a file, the agent rebuilds its prompt without restarting.

`/quality` runs fmt, clippy, compile, tests, doc-tests, and a security audit in sequence. Failures include stack traces and diff context. Warnings are non-blocking by default; you can promote them to gates per project.

Stdio JSON-RPC 2.0, managed subprocess, same permission and audit pipeline as builtins.

MCP servers are declared in Aura's config: command, arguments, environment. On session start, Aura spawns them as managed subprocesses, runs the typed capability handshake from `dweve-protocol::mcp::capability`, and registers the discovered surface in the same tool registry the builtins live in. Resources, tools, prompts, sampling and logging capabilities all flow through the same typed message bus from `dweve-protocol::mcp::message`. External tools aren't trusted by default, they inherit per-tool permission levels, audit logging, PII filtering and circuit-breaker protection.

Aura's MCP client is built on `dweve-protocol::mcp`, the typed MCP message, capability, transport and tool surface that the rest of Dweve also uses. Connect to any MCP server over stdio JSON-RPC 2.0, negotiate capabilities, and surface its tools / prompts / resources alongside Aura's builtins. Same permission gate, same audit trail, same circuit breaker.

Agents share a task board, exchange messages via the event bus, and enforce quality gates. Cross-agent work ledger tracks file-level claims to prevent conflicts.

Spawn multiple agents simultaneously with the same input. Aggregation strategies: unanimous (all agree), majority (most common), first-success (fastest valid), or custom merge.

Multi-step execution where each step's output feeds into the next. Variable substitution with Jinja-like syntax. Built-in chains for debug, feature, optimisation, refactor, and review.

Chains are defined as markdown files with YAML frontmatter, a name, description, ordered steps. Each step names an agent, specifies a goal, and may reference the output of previous steps through Jinja-like variables. Success criteria declare what counts as completion (substring match, regex, file existence, test pass). Built-in chains cover debug, feature implementation, optimisation, refactor and review. Drop a markdown file in the chains directory to define a custom one, no rebuild.

Aura's agent registry supports four orchestration patterns. Chains execute agents sequentially with variable substitution. Parallel runs agents concurrently with result aggregation. Teams coordinate multiple agents with shared state and messaging. Background tasks run independently with abort handles and status tracking.

Three-tier compactor merged stale tool output at high utilisation.

Classifier picked claude-sonnet for moderate-complexity task.

Every event lands on its own line in an append-only JSONL file. Each line carries the BLAKE3 hash of the previous, so verifying the chain from start to current detects any modification. Not a best-effort log, a cryptographic decision journal.

Trim to fit context budget; lowest-scoring drop.