Aura is an open, terminal-native agent harness. The model is the brain — Aura is everything around it: tools, sessions, skills, swarms, perception and computer use, composed so your agent keeps working in real scenarios, not toy ones.
Read, edit, bash, perception, computer use — capabilities are pluggable and replaceable. The harness only orchestrates; the abilities compose.
Append-only session logs capture prompts, reasoning, tool calls and results. Resume, fork, retrieve and replay any conversation, ever.
No sidecar app, no browser round-trip. Aura runs in your terminal, on your machine, against your real files — with an optional web client.
Before Aura plans a change, it first builds a structural map of the repository. Files, symbols and dependencies become a queryable graph, so the agent can understand how the code fits together instead of treating every search result as an isolated fragment.
Perception is Aura’s read layer: it extracts the codebase once, stores relationships between its parts, and lets agents ask focused questions about ownership, dependencies and impact before they edit.
Aura identifies files, symbols and dependency links, then records them as nodes and edges. The result is a navigable model of the repository, not a flat list of filenames.
The graph exposes what imports what, where a symbol lives and which parts of the project depend on it. That makes likely impact visible before a change begins.
Agents query the map for the context a task needs, then open the relevant source. Search finds matching text; Perception explains where that text sits in the system.
◈ graphify repository files → symbols → imports → dependents ◈ query: what changes if this symbol moves? focused context shared with the agent before execution
Aura Memory is an event-sourced learning pipeline. It records what actually happened, distills the signal once, and lets repetition, recency and consistency decide what deserves to follow you into the next session.
No model assigns an arbitrary importance score. A memory earns depth by surviving time: repeated truths strengthen, stale noise disappears, newer understanding supersedes the old, and contradictions are surfaced for you to resolve.
Every task becomes an atomic, project-scoped episode: request, model, outcome, tokens and duration. Recording never blocks the work.
One focused pass turns recent episodes into concrete lessons, recurring patterns, open threads and a brief for tomorrow.
Claims are kept, merged, strengthened, superseded, dropped or flagged as conflicts using deterministic evidence across dream cycles.
A bounded canonical view combines identity with the strongest lessons and enters every CLI or Telegram session as silent context.
claim observed once KEEP repeated across dreams STRENGTHEN · 0.67 newer understanding SUPERSEDE positive + negative CONFLICT · ask human one-off, 3+ cycles old DROP
The whole harness, in a browser tab. One command serves the full web client from the same machine your agent runs on — the kanban board, the chat, the code, the settings. No cloud round-trip: :auraweb inside a session, or webaura from a plain terminal.
Every swarm you launch lands on a kanban in your browser — lanes glow red → orange → green as execution phases complete. Click a card to expand it, rewrite its title inline, bin it from the corner.
Streaming conversation with the running agent. Type while a task is in flight and it's folded into the next turn — work so far is never lost.
Diffs, files and the perception canvas — the graphified repo, navigable. What the agent knows, you know.
Providers, models, plugins and skills from a marketplace name, an owner/repo, a git URL or a local path — Claude extensions, DeepSeek extensions and private repos install the same way.
Serbian is Cyrillic only — no script toggle exists to get wrong. Arabic mirrors the whole layout with real logical properties, not a transform.
$ :auraweb --port 8080 ◈ serving the web client on http://localhost:8080 ◈ board · chat · code · canvas · settings — in your browser
One agent is a worker. Launch a swarm and watch a kanban fill itself: per-lane glows, phased execution, and a model picker on every agent.
Providers are plugins. Point Aura at whatever brain you want — swap mid-session, mix across a swarm.
$ aura model use glm-4.7 ✓ provider: zhipu · reasoning: on $ aura swarm launch --agents 4 ✓ architect → claude-sonnet-5 ✓ coder×2 → glm-4.7 ✓ reviewer → haiku-4.5 kanban: [████████░░] lanes glowing…
One command. Then meet your agent where it lives — in the terminal.
$ npm install -g aura-code $ aura ◈ aura v0.16.x — terminal agent harness ◈ try: "graphify this repo and brief me"
Thirty-eight seconds of the real client — memory, board, plugins, chat. No music, no narration. Just the machine.