DEV Community

Cover image for AURA: The Verifiable Runtime Coat & Attestation Spine for AI Agents

AURA: The Verifiable Runtime Coat & Attestation Spine for AI Agents

How AURA (machine-aura) wraps existing agent loops with policy gates, secret redaction, cost circuit breakers, and offline-verifiable signed audit packs—without owning your loop.


The Problem: Agents Are Easy to Build, Hard to Prove

You can wire an AI agent to tools in an afternoon. Putting that same agent into production in finance, healthcare, enterprise SaaS, or hardware automation hits a wall:

  • What did the agent actually do? Logs are scattered, mutable, and rarely tied to a cryptographic trail.
  • Did a tool call leak a secret or PII? Raw API keys, bearer tokens, and customer data slip into trace logs and error messages.
  • What happens when an agent loops or burns budget? A runaway retry loop can burn thousands of dollars in minutes.
  • How do you prove compliance offline? Auditors and incident teams don't want access to your live runtime—they want a self-contained, tamper-evident artifact they can verify independently.

AURA (pip install machine-aura) solves this without asking you to rewrite your agent framework.


What Is AURA?

AURA is a verifiable runtime coat and attestation spine for AI agents.

It wraps whatever runs your agent loop—a plain Python script, Skillware, LangGraph, or your own custom host. It does not replace your orchestrator, model, or tool runtime. Instead, it sits at the egress boundary, mediating every tool/skill call and recording every action onto a SHA-256 hash-chained audit spine.

Zero-dependency at its core, AURA turns opaque agent runs into provable, auditable execution records.


Who Is It For?

  • Platform & AgentOps Engineers who need USD cost circuit breakers, loop/cycle detection, and OpenTelemetry GenAI spans without vendor lock-in.
  • Security & AppSec Teams who need automatic secret/PII redaction, SSRF-safe webhook delivery, and credential isolation (SecretBroker) so agents never touch raw os.environ secrets.
  • Compliance & Risk Teams (FinTech, Healthcare, Regulated Enterprise) who need offline-verifiable, cryptographically signed audit packs (.pack.json) and dual-ledger verification.
  • Hardware & Bioware Automation Teams who need manifest-level safety gates before an agent can trigger physical-world actions.

How It Works

Your Agent Loop (Host / LangGraph / Skillware / Python)
   │
   ▼  (Egress boundary)
AURA Runtime Coat
   ├── Policy & Schema Gates (spectrum posture, physical-substrate gates)
   ├── Secret & PII Redaction (unified pattern scrubbing, SecretBroker)
   ├── FinOps & Observers (USD cost circuit breaker, loop/drift detection)
   └── SHA-256 Hash-Chained Audit Spine
         │
         ├──► JSONL + Summary + Audit Report
         ├──► OTel GenAI Spans
         └──► Signed Audit Pack ({session_id}.pack.json) ──► Offline `aura verify pack`
Enter fullscreen mode Exit fullscreen mode

Quick Start (Zero-Dependency Core)

Install from PyPI (renamed from aura-harness to machine-aura in 0.3.7):

pip install machine-aura
Enter fullscreen mode Exit fullscreen mode

Wrap a session in 6 lines of Python:

from aura import agent, configure

configure()

ag = agent("acme/research-bot", policy_version="1")
with ag.session(signed_pack=True) as run:
    run.emit("turn.start", {"input": "Summarize Q3 risk report"})
    run.emit("turn.end", {"tokens": 420})

print(run.exports)
Enter fullscreen mode Exit fullscreen mode

Verify the exported bundle offline from the CLI:

aura verify chain ./aura_sessions/<session_id>/events.jsonl
aura verify pack ./aura_sessions/<session_id>/<session_id>.pack.json --key "$AURA_SIGNING_KEY"
Enter fullscreen mode Exit fullscreen mode

What's New in AURA 0.3.7

1. Signed Audit Packs & Offline Verification

Compliance teams shouldn't need access to your production database to trust an agent's execution log. With signed_pack=True, AURA emits export.signed_pack on the spine and atomically writes {session_id}.pack.json containing:

  • The chain_root of the SHA-256 audit spine
  • SHA-256 digests of every exported artifact
  • A detached cryptographic signature (hmac-sha256 zero-dependency default, or ed25519 when cryptography is installed)

2. AURA-Native Coat Ops (WebhookCoatOp, SmtpCoatOp, CoatOpRunner)

When an observer or SLO rule triggers an escalation (escalation.email, escalation.wake), AURA now ships native, zero-dependency delivery primitives:

  • WebhookCoatOp with built-in SSRF URL validation and X-AURA-Signature HMAC-SHA256 signing
  • SmtpCoatOp using stdlib smtplib
  • CoatOpRunner for membrane-level scans routed through SkillwareHost egress

3. Skillware 0.6.2+ Dispatch Bridge & Dual-Ledger Verification

If you run Skillware skills, SkillwareHost.create_context() bridges SkillContext on_dispatch events directly into AURA's AuditSpine with correlated trace_id/span_id. Optional verify_dual_audit_chain() cross-verifies AURA's spine against Skillware's own JSONL log to catch tampering, truncation, or unanchored shadow executions (UNGUARDED_SKILL_DISPATCH).

4. Egress FinOps, OTel GenAI & USD Cost Circuit Breakers

AURA tracks latency_ms, model, token counts, and estimated_cost_usd per egress call, emits OpenTelemetry GenAI semantic attributes (gen_ai.request.model, gen_ai.usage.*, error.type), and lets LimitObserver enforce max_cost_usd budget warnings and hard circuit breakers.

5. Manifest v2 Physical-Substrate Safety Gates & Unified Secret Redaction

  • Physical safety: SkillwareHost validates Manifest v2 schemas and auto-gates exclusively physical hardware/bioware skills (hardware_gate="auto") before execution.
  • Secret hygiene: redact_secret_patterns() scrubs raw credentials (sk-..., ghp_..., AIza..., AKIA..., Bearer ..., PEM keys) across all free-form strings and error messages.
  • Async egress: guarded_tool_call_async, SkillwareHost.aexecute(), and a thread-safe (RLock) AuditSpine.

Industry Scenarios

  • FinTech & Banking: Export signed_pack=True bundles for every automated underwriting or KYC agent run; verify them offline in audit pipelines with aura verify pack.
  • Enterprise SaaS: Wire LimitObserver(max_cost_usd=5.0) and redact_secret_patterns so customer-facing agents never leak API keys in error traces or blow through token budgets.
  • Robotics & Bio/Lab Automation: Use hardware_gate="auto" to require explicit human confirmation before a physical-substrate skill executes, while keeping pure-software math/lookup tools unblocked.

Get Started

Top comments (0)