Halo Record Agent Audit Trails
Create tamper-evident AI agent audit trails that customers can verify independently.
- Source repo
- bkuan001/halo-record
- Stars
- ★ 80
- Last updated
- 11d ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 85/100 · Good
At a glance
- How it runs
- 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
- 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.
- An AI software vendor answering a customer's security team with a verifiable Runtime Report showing how its agent handled customer data.
- 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.
- A platform team combining LangChain, LangGraph, MCP, or OpenTelemetry GenAI events into one chain while retaining source provenance.
- An engineering team recording Claude Code or Codex file changes, shell commands, and MCP calls without modifying the coding agent.
- A high-assurance deployment asking a customer or another outside party to retain periodic checkpoints so committed-history rewrites become detectable.
- 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 --serveAlternatively, install it with pip and start the demo:
pip install halo-record
halo demo --serveThe 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.htmlTo serve customer-scoped reports from a records directory, run:
halo serve ./records --port 8721For 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 --checkWhat are this agent's strengths and limitations?
- 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
sourcetag 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.
- 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
Recorderneed 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?
Why each dimension lost points
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.
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.
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.
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.
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.
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.
- 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.
FAQ
Does local use require a paid service or model API key?
Can it prove that every agent action was recorded?
What happens if recording fails?
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?
Can several worker processes append to one chain?
Recorder provides a sidecar lock; direct writers must implement an equivalent lock or write separate chains.