Halo Record Agent Audit Trails

Create tamper-evident AI agent audit trails that customers can verify independently.

Stars
★ 80
Last updated
11d ago
License
Apache-2.0
Primary language
Python

At a glance

How it runs
CLILibrary / SDKSelf-hosted service
Works with
Universal · cross-platformCodex · Claude Code · OpenAI API · Claude API
Cost
Free, no paid service needed
Setup effort
Low · running in minutes
You'll need
Pythonpip or uvShell / CLILocal filesystem
Typical use
An AI software vendor answering a customer's security team with a verifiable Runtime Report showing how its agent handled customer data.
Not a fit if
  • Teams that need proof every real-world action was captured
  • Teams requiring built-in retention, pruning, or complete deletion of chained personal data
  • Systems unable to serialize writers or give parallel workers separate chains
Source review
85/100 · Good

What does this agent do, and when should you use it?

Halo Record is a dependency-free Python reference implementation for hash-chained records of agent runs, tool calls, model calls, data access, and approvals. It includes `Recorder`, `trace`, `record_call`, framework adapters, a verifier, a witness client, a report server, and a CLI, with documented paths for MCP, LangChain/LangGraph, OpenAI Agents SDK, Claude Agent SDK, OpenTelemetry GenAI, LiteLLM, Langfuse, and gateway logs. Records are appended to local JSONL chains and can be rendered as browser-verifiable Runtime Reports or exported as CSV with a manifest tied to the source chain head. Checkpoints held by an external witness can expose rewritten committed history or missing checkpoints, while optional RFC 3161 timestamps establish that a chain state existed no later than an attested time. This is an evidence layer rather than a certification system or enforcement gateway: hashes do not prove every action was captured, and a sealed verification status only preserves what the integration reported. Core recording and verification run locally; networking is limited to explicitly invoked witness and timestamp operations.

At an action boundary, an application uses Recorder, trace(), record_call(), or a framework adapter to seal a canonical input hash, an optional best-effort redacted summary capped at 200 characters, the outcome, subject, provenance, parent link, and optional verification and authority blocks. Each record is canonicalized with RFC 8785, hashed with SHA-256, and connected to its predecessor through integrity.prev_hash; halo verify recomputes the hashes and validates both schema and links. halo report produces self-verifying HTML, halo serve exposes customer-scoped reports, halo export creates a date-bounded CSV and manifest, and halo policy evaluates declarative rules as passes, violations, or evidence gaps. halo anchor sends the subject ID, record count, chain head, and chain root to a local or remote witness and can attach an RFC 3161 time proof; record contents are not included in that request. Existing systems can also feed the format through MCP interception, LangChain callbacks, OpenTelemetry GenAI spans, LiteLLM callbacks, Langfuse exports, gateway logs, and Claude Code or Codex PostToolUse events.

  1. An AI software vendor answering a customer's security team with a verifiable Runtime Report showing how its agent handled customer data.
  2. A compliance team preparing date-bounded logging evidence for SOC 2, AIUC-1, AICM, ISO 42001, the EU AI Act, or NIST AI RMF reviews.
  3. A platform team combining LangChain, LangGraph, MCP, or OpenTelemetry GenAI events into one chain while retaining source provenance.
  4. An engineering team recording Claude Code or Codex file changes, shell commands, and MCP calls without modifying the coding agent.
  5. A high-assurance deployment asking a customer or another outside party to retain periodic checkpoints so committed-history rewrites become detectable.
  6. An audit team exporting only relevant tool calls as CSV plus a verification manifest for upload to a GRC platform such as Vanta or Drata.

How do you install or deploy this agent?

The local demo requires no agent, account, or API credential. With uv, run the package directly:

uvx --from halo-record halo demo --serve

Alternatively, install it with pip and start the demo:

pip install halo-record
halo demo --serve

The demo creates a fictional vendor with two customers, checkpoints the chains to a local witness file, serves their Runtime Reports, and opens the operator console. The Apache-2.0 package is usable for free; networking is needed only if you explicitly choose a remote witness or RFC 3161 timestamp service.

How do you use this agent?

Wrap a Python agent entry point to record the run boundary:

from halo_record import trace

agent = trace(run_my_agent, profile="my-agent", log="audit.jsonl")

Capturing individual tool calls requires record_call() at each boundary or a supported adapter:

from halo_record import Recorder, record_call

rec = Recorder("audit.jsonl")

with record_call(rec, "crm.lookup", {"account": "acct-9"}) as call:
    call.result = crm.lookup("acct-9")

with record_call(rec, "payments.refund", {"amount": 120},
                 parent_id=rec.last_record_id()) as call:
    call.result = payments.refund(120)

Verify the chain and render a report:

halo verify audit.jsonl
halo report audit.jsonl -o report.html

To serve customer-scoped reports from a records directory, run:

halo serve ./records --port 8721

For Claude Code, add this to ~/.claude/settings.json:

{
  "hooks": {
    "PostToolUse": [
      {"matcher": "*", "hooks": [{"type": "command", "command": "halo hook"}]}
    ]
  }
}

For Codex, add this to ~/.codex/hooks.json:

{
  "hooks": {
    "PostToolUse": [
      {"matcher": ".*", "hooks": [{"type": "command", "command": "halo hook"}]}
    ]
  }
}

Both hook configurations write to ~/.halo/audit.jsonl by default. HALO_LOG changes the destination, and HALO_HASH_ONLY=1 disables summaries. To commit history to a witness and check it later, run:

halo anchor audit.jsonl witness.jsonl
halo anchor audit.jsonl witness.jsonl --check

What are this agent's strengths and limitations?

Pros
  • The runtime uses only the Python standard library; core recording and local verification need no external service or network.
  • An open format, RFC 8785 canonicalization, and SHA-256 chaining let third parties implement independent verification without a secret key.
  • It supports both boundary capture and telemetry ingestion, with a source tag disclosing how each piece of evidence was collected.
  • External checkpoints strengthen historical integrity, and optional RFC 3161 proofs add independently verifiable time without sending record contents.
  • Outputs cover self-verifying HTML, policy findings, and CSV evidence with both a source-chain head and an export-file hash.
  • The documentation explicitly separates record integrity, capture completeness, and trusted capture instead of presenting a hash chain as universal proof.
Limitations
  • A self-held chain only detects edits relative to a previously established head; before an outside party sees a head, the operator can remove records and reseal.
  • No hash chain proves that every real action passed through the recorder; completeness still depends on instrumentation placement and the capture boundary.
  • Redaction is best-effort regex and entropy detection, so names, postal addresses, and free-form sensitive text may become permanent chain content.
  • There is no built-in retention or pruning; deleting chained records breaks subsequent verification, so personal-data handling requires external pseudonymous mappings.
  • Chains require single-writer semantics; parallel writers bypassing Recorder need an equivalent lock or separate per-process chains.
  • Framework callbacks fail open by default, allowing an action to complete when evidence cannot be written; only checkpoint cadence can reveal a stalled chain.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Halo Record Agent Audit Trails This agent 85 · Good CLIFree ★ 80 11d ago Python Codex · Claude Code · OpenAI API · Claude API
OpenInference 71 · Some gaps Library / SDKFree ★ 1.2k 1d ago Python OpenAI API · Claude API
Cordum Agent Control Plane 64 · Some gaps Self-hosted serviceFree ★ 508 4d ago Go Claude Code
TruLens Agent Evaluation & Tracing 51 · Major gaps Library / SDKFree + model costs ★ 3.6k 1d ago Python OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Good
85/ 100 5-point scale 4.3 / 5
Trust 23/29
Reliability 11/14
Adaptability 16/18
Convention 15/18
Effectiveness 12/13
Verifiability 8/8
Why each dimension lost points
Trust23 / 29 · 4.0/5

The project presents a local recorder with no runtime dependencies and limits networking to explicitly invoked witness anchoring, checkpoint retrieval, and RFC 3161 timestamping, including a clear account of the fields transmitted. This strongly supports least privilege, data-flow transparency, and external-effects disclosure. Tool inputs are stored as hashes with capped, best-effort redacted summaries, and hash-only mode is available; however, the documentation concedes that names, addresses, free text, caller-supplied outcome fields, and guessable hashed values may remain sensitive, so sensitive-data handling is not complete. Network actions are opt-in, but there is no general interactive confirmation layer, resulting in a deduction for user confirmation. Having no runtime dependencies reduces supply-chain exposure, but the build dependency has an open lower bound and CI actions are not pinned to commit digests, so dependency security scores 2. Append-only records have no built-in deletion, pruning, or recovery path, making rollback weak. Authorship, licensing, security contact, capture source tags, and evidence tiers are attributed clearly; the unverified publisher is treated as unknown and is not itself penalized.

Reliability11 / 14 · 3.9/5

The README is internally consistent about integrity, completeness gaps, external witnessing, single-writer constraints, and fail-open versus fail-closed integrations. The supplied anchor and access tests cover success, tampering, truncation, expiry, and malformed inputs. Python 3.8+, standard-library runtime operation, and ordinary pip/uv installation support availability, but setuptools, optional TSA tooling, OpenSSL/curl, and framework-specific integrations remain environmental dependencies, so this is not full marks. Failure behavior is explained and includes stderr warnings, lost-record counters, and reasons for failed completeness checks, but the supplied material does not demonstrate consistently actionable messages for every CLI, disk, network, and parsing failure.

Adaptability16 / 18 · 4.4/5

The material identifies developers, security reviewers, customers, and compliance teams as audiences and supplies native wrappers, explicit calls, LangChain, MCP, OpenTelemetry, gateway ingestion, and coding-agent hooks. Capability boundaries are unusually explicit: a chain cannot prove capture completeness, a verification block cannot prove the check occurred, and the built-in timestamp check does not validate the TSA signature. Trigger configuration and capture timing are described, but wildcard hooks, orchestration-event filtering, and exact adapter coverage are supported mainly by documentation rather than comprehensive supplied tests, so trigger precision scores 2.

Convention15 / 18 · 4.2/5

The README is well structured around threat boundaries, installation, demonstrations, integrations, failure behavior, privacy, and compliance, with runnable examples and misuse warnings. It references dedicated limits, privacy, retention, and reviewer documentation, while the excerpt itself explains major limitations in detail. The complete Apache-2.0 license agrees with package metadata. Naming is less stable because halo-record, halo_record, and halo coexist, the halo import can collide with another PyPI project, and an exported record function shadows a module; the workarounds are documented but the friction remains. Version 0.2.45 and Alpha status are declared, yet no changelog, release history, or compatibility policy is supplied, so versioning/changelog scores 1. An author, issue tracker, security email, and claimed response window establish responsibility, but no broader governance, succession, or sustained maintenance process is evidenced.

Effectiveness12 / 13 · 4.6/5

The repository describes directly usable JSONL chains, self-verifying HTML reports, checkpoints, and verification commands. Source tags, verification metadata, and model-call fields make the output suitable for an audit review. Hash chaining, external checkpoints, and independent verification provide clear marginal value over conventional logs. Zero runtime dependencies, a one-line wrapper, and multiple adapters reduce adoption cost, but credible historical completeness still requires a trusted external witness, capture completeness depends on correct instrumentation, and operators must manage single-writer coordination, storage, privacy, TSA verification, and retention. The package is also explicitly Alpha, so cost-benefit is strong but not fully established.

Verifiability8 / 8 · 5.0/5

The core claims are separated into edit detection, committed-history detection, and capture completeness, then tied to specific limitations, commands, fields, and test scenarios. The supplied tests corroborate checkpoint construction, chain roots, truncation detection, mismatched chains, and access controls. README, SECURITY, pyproject, CI, license, and tests broadly agree on runtime dependencies, network boundaries, attribution, licensing, and verification behavior. The documentation consistently separates what hashes prove, what operators merely assert, what depends on external trust, and what is a future commercial proposition. Full marks here reflect the quality of the static evidence only; no code was executed and no claim was independently reproduced.

Risks and how to mitigate them
  • Do not treat a self-held hash chain as proof of complete history; until a trusted external party holds checkpoints, the operator can remove records and reseal the chain.
  • Redaction is defense in depth, not data-loss prevention. Names, addresses, free text, outcome fields, and hashes of guessable values may expose or confirm personal data; prefer hash-only capture and deletable external mappings in production.
  • The append-only chain has no built-in deletion, pruning, or enforced retention. Design retention, segregation, and mapping-deletion procedures before recording personal data.
  • Framework callbacks and post-action hooks may fail open: an action can execute without a record after a write failure, while the remaining chain still verifies normally.
  • Maintain one lock-protected writer per chain; direct cross-process or cross-language writes can create forks.
  • The built-in timestamp check does not validate the TSA signature; production review requires an independent standard tool and an appropriate TSA trust chain.
  • The package is marked Alpha, and the supplied evidence contains no changelog or compatibility policy. Pin versions and review format and CLI changes before upgrading.
  • This assessment uses only the supplied static files. Tests were not run, and the published package, sample report, linked documents, and network behavior were not independently verified.
Evidence confidence: Low Reviewed Sep 26, 2026 Reviewed revision fdc59d2bb9fb
See the full review method →

FAQ

Does local use require a paid service or model API key?
No. The Apache-2.0 software can demo, record, verify, report, and witness locally without an API credential. Remote witnesses and RFC 3161 timestamps are optional network operations.
Can it prove that every agent action was recorded?
No. The chain proves integrity relative to an established head, and external checkpoints can expose rewrites of committed history. Capture completeness remains a property of where and how the recorder is integrated.
What happens if recording fails?
The native trace() wrapper fails closed, so a write exception propagates into the action. Framework adapters such as the LangChain handler fail open: the action continues, while a warning and loss counter report the missing evidence.
Are tool arguments or customer records sent to a witness?
No. A witness receives only the subject ID, record count, chain head, and chain root; an RFC 3161 authority receives only a checkpoint state hash. Local summaries still require care because redaction is not guaranteed.
Can several worker processes append to one chain?
Only if the entire read-head-and-append sequence is protected by an exclusive lock. Recorder provides a sidecar lock; direct writers must implement an equivalent lock or write separate chains.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents