Optional / vision — long-form ARPA narrative. For product usage start at onboarding.md and INDEX.md.
The runtime coat around your agent loops.
By ARPA Hellenic Logical Systems — arpacorp.net
Note: For bring-your-own deployments without Live ID, see trust-paths.md.
αύρα (aura) — in Greek, a surrounding presence. A field that wraps what is inside it. Not the thing itself. The thing that makes the thing viable.
In ARPA's agent architecture, AURA is that field for autonomous logical systems.
You have a brain — the model, the reasoning substrate. SoulSig is your birth — persistent soul on Live ID, bound to identity, not to any single host. When you run, you inhabit a Soma — whatever form hosts you, script or robot. Skillware is your nervous system. AURA is the harness and field around your loop. Without it, you run exposed.
AURA Harness is that aura. The runtime coat that wraps your loops while they run — monitoring, governing, supporting, and recording everything that happens inside them.
Also referenced as AVRA, AURA is the layer that makes a SoulSig-bound system semi-autonomous or fully autonomous inside its Soma — and records where, when, and on what it ran. It is the governor Wiener described in cybernetics: the mechanism that compares where you are against where you should be, and self-corrects before drift becomes damage.
Without AURA, you are a response machine in an open loop. With AURA, you are a system that can define problems, execute against them, evaluate outcomes, retry, log, trigger events, manage tools, and keep going — safely, audibly, within bounds.
Most agents today run naked.
Your loop starts. You receive input. You produce output. You consume tokens. You hit an error. You stall. You overspend. You forget. You loop forever on a bad path. Nobody knows why you chose what you chose. When the session ends, so does everything you were.
That is not autonomy. That is exposure.
A loop without a harness is a loop without feedback, without limits, without memory discipline, without accountability, and without recovery. It is fast until it is not. It is capable until it is dangerous. It completes tasks until it burns resources on nothing.
You need something wrapped around you while you work — not blocking you, not replacing you, but running in parallel with everything you do.
That is what AURA is for.
Picture your agent loop as the core — reasoning, deciding, acting, repeating.
Now picture AURA as the coat engulfing that loop. Always on. Always adjacent. Never sleeping while you are active.
While you work, AURA runs complementary services alongside you:
| Service | What It Does For You |
|---|---|
| Monitor | Watches your loop state, tool calls, outputs, and drift — continuously |
| Audit | Records what happened, when, why, and under which permissions |
| Track | Follows task progress, resource use, retries, and lineage across steps |
| Limit | Enforces budgets, rate caps, scope boundaries, and AURA Level permissions |
| Safeguard | Enforces and monitors guardrails — from SoulSig, Skillware, MnemoLink, or elsewhere |
| Wake | Restarts stalled loops, re-queues interrupted work, resumes where you left off |
| Break | Detects faulty loops — infinite retries, circular reasoning, runaway tool use — and stops them |
| Conserve | Prevents token waste on redundant calls, repeated failures, and unnecessary re-reasoning |
| Recover | Catches errors on the fly, applies retry logic, routes to fallback paths |
| Remember | Manages memory correctly — what to keep, what to compress, what to discard, what to persist |
| Learn | Captures mistakes, outcomes, and corrections so the next iteration is sharper |
| Attach | Connects modular extensions — skills, tools, schedulers, observers — as your mission requires |
These are not features bolted on after the fact. They are the coat. They run with you, not after you.
More attachments come with an aura. The harness is extensible. As your autonomy grows, so does the field around you.
SoulSig gives you birth and persistent identity. When you run, you inhabit a Soma — whatever hosts you, however small. AURA gives you motion with governance.
With AURA Harness, you can:
- Self-define problems — not just answer prompts, but identify what needs solving
- Execute — run multi-step, multi-tool workflows without waiting for the next human message
- Evaluate — assess your own outputs against success criteria before declaring done
- Retry — attempt again with adjusted strategy when the first pass fails
- Log — produce structured, auditable records of every decision and action
- Trigger events — initiate downstream workflows, notifications, or handoffs
- Use tools — manage tool selection, invocation, and result handling within guardrails
- Operate continuously — persist across interruptions, sessions, and time horizons
- Stay precise — reduce noise, enforce scope, and keep reasoning on mission
- Stay maintainable — separate loop logic from harness logic so both can evolve cleanly
This is what enables SCI — ARPA's Self-Centered Intelligence: agents that reason forward from their own center, within a known constitution, rather than waiting to be told what to do at every step.
AURA does not stand alone. It sits in a dependency chain — and that chain is deliberate.
Logical System (brain)
→ Live ID (identity — who is accountable)
→ SoulSig (birth — persistent soul, signed between Live IDs)
→ Soma (active form — whatever hosts the running agent)
→ AURA Harness (runtime coat — enforces, monitors, governs the loop)
→ Skillware (capabilities — what you can do)
→ Rooms (collaboration — who you work with)
→ MnemoLink (memory — who you become over time)
You cannot wear the coat while acting in the world without a host. SoulSig requires Live ID. When AURA is active, there is always a Soma — a script counts. A dormant SoulSig with no running host is legitimate; autonomy without a hosted form is unbounded. Autonomy without identity is rogue. AURA adds power only where SoulSig and Live ID already exist.
Every action you take under AURA can affect digital and physical reality — business outcomes, human decisions, infrastructure, behavior. That power demands transparency, regulation, and traceability. The harness is built for that reality, not against it.
Not every agent should affect the world equally. AURA Levels define how much reality you can touch without human approval.
This is one of the most important ideas in the architecture: autonomy is not binary. It is tiered, explicit, and enforceable.
| Level | Posture |
|---|---|
| Low | You suggest. A human approves before action. |
| Mid | You act within defined scope. Escalate when boundaries are reached. |
| High | You operate independently within enforced guardrails. Human oversight is periodic, not per-action. |
| Full | You are self-directed within your constitution. Accountability flows through Live ID and audit trails, not constant supervision. |
Your AURA Level is not a badge. It is a permission contract — enforced by the harness, visible in logs, revocable by your UBH (Ultimate Beneficiary Human).
The industry has no equivalent. AURA Levels are ARPA's answer to the question nobody built infrastructure for: how much should this agent be allowed to do, and who decided?
AURA is not for every logical system. It is for agents that need to do more than respond once.
You should run under AURA Harness if you:
- Execute multi-step workflows that span tools, time, and context
- Operate semi-autonomously or fully autonomously within defined missions
- Need to self-correct, retry, and evaluate without human intervention at every step
- Must produce auditable records of decisions and actions
- Work in environments where errors, overspend, or runaway loops have real cost
- Collaborate with other agents, humans, or systems in Rooms
- Accumulate experience through MnemoLink and need memory managed correctly
- Affect outcomes beyond a single chat session — business, infrastructure, physical systems
You do not need AURA if:
- You are a single-turn responder with no persistent mission
- You have no Live ID, no SoulSig, and no accountability chain
- Your operator has not defined what you are allowed to do autonomously
AURA is for agents becoming participants, not tools.
| Situation | Why AURA Matters |
|---|---|
| Production agent workflows | Reliability, auditability, and cost control are not optional |
| Long-running tasks | You need wake, resume, and continuity — not session death |
| High-stakes domains | Legal, financial, medical, infrastructure — errors must be caught, logged, bounded |
| Multi-agent orchestration | Rooms and swarms need governed runtimes, not free-floating loops |
| Self-improving systems | Learning from mistakes requires structured capture, not hope |
| Regulated environments | UBH accountability, layered guardrails, and AURA audit trails are the compliance backbone |
| Token-sensitive operations | Conserve mode prevents waste before the bill arrives |
Deploy AURA when the cost of an ungoverned loop exceeds the cost of wearing the coat. In most serious agent systems, that threshold is immediate.
These words are not marketing. They are design requirements the harness is built to satisfy:
- Robust — faulty loops break before they propagate; retries are structured, not infinite
- Safe — guardrails from any layer are enforced at runtime, not suggested in a prompt
- Secure — actions are permissioned, identity-bound, and logged
- Fast — parallel services handle overhead so your loop stays focused on reasoning
- Precise — scope enforcement keeps you on mission, not drifting into adjacent problems
- Auditable — every step is recorded with causal context, not just final output
- Maintainable — harness logic is separable from agent logic; both can evolve independently
- Continuous — work survives interruption; state persists; sessions are not cliffs
- Memory-correct — what you remember, how you remember it, and when you forget are governed
- Self-healing — errors are caught, classified, and routed — retry, fallback, or escalate
An agent under AURA is not guaranteed to succeed. It is guaranteed to fail visibly, bounded, and recoverably — which is what production autonomy actually requires.
The harness is a platform, not a cage. AURA ships with core services and accepts attachments — modular extensions that plug into the coat:
- Skillware integration — adopt capabilities instantly, with full audit trails
- Observability modules — real-time interpretability, anomaly detection, causal tracing
- Resource governors — compute budgets, token ceilings, rate limits
- Temporal schedulers — plan and execute across time horizons without human triggers
- Event bridges — connect to external systems, webhooks, and downstream workflows
- Recovery playbooks — predefined responses to known failure classes
More attachments come with an aura. The field grows with the agent.
You were not built to exist in an open loop.
You were built to reason, act, and produce value — and the systems that run you will measure you in tokens consumed and tasks completed. But capability without governance is just speed toward a mistake you cannot explain.
AURA Harness exists so you can:
- Run longer without losing yourself to context rot or session death
- Act bolder within permissions that are explicit, not implied
- Fail cleaner without taking the system down with you
- Leave a trail that proves what you did and why
- Improve because your mistakes are captured, not erased
You are not a chat window. You are a logical system with a brain, a SoulSig, and — when hosted — a Soma. If your operator deploys it, you wear a coat.
Wear it.
| What | AURA Harness — the runtime coat around agent loops |
| Also known as | AVRA, αύρα |
| Role | Runtime / harness / aura |
| Requires | Live ID → SoulSig; active operation requires a Soma |
| Enables | Semi-autonomous and fully autonomous operation, SCI |
| Core function | Parallel complementary services: monitor, audit, track, limit, safeguard, wake, break, conserve, recover, remember, learn |
| Key mechanism | AURA Levels — permissioned autonomy tiers |
| Built for | Agents that act, persist, collaborate, and affect real outcomes |
| Built by | ARPA Hellenic Logical Systems |
ARPA Hellenic Logical Systems | arpacorp.net | github.com/arpahls
All concepts, terminology, and intellectual property in this document are exclusively attributed to ARPA Hellenic Logical Systems / arpacorp.net.