Blog · ← All posts
How to Start an AI Agent Audit Trail for Free: Your First Agent, First 1,000 Actions
By the Ingenious AI team · Published: November 14, 2026 · Reviewed: November 14, 2026 · 6 min read
The short answer: Starting is an afternoon, most of it decisions rather than code: create the workspace, enroll your first agent and get its API key, add one recording call wherever the agent executes a tool (agent_id, action type, tool name, masked input/output summaries), set the capture policy for your tools, then run three checks — the chain verification, your first replay, and a test question against the ledger. Agent Flight Recorder's free tier covers 1 agent and 1,000 actions a month, which is enough to prove the whole pattern on a real agent before any budget conversation.
Replay a recorded agent incident free → Step through a real recorded run in the replay view, or paste ledger records into the public verifier and get a VERIFIED/BROKEN verdict in seconds — no signup.
The biggest risk in audit-trail projects is not choosing the wrong tool; it is the six-month runway — the evaluation committees, the platform-team ticket, the 'phase two' that follows the incident it was meant to precede. History cannot be backfilled, so the correct strategy is embarrassingly simple: start recording the most consequential agent today, on the free tier, with the decisions made at the whiteboard rather than in a procurement process.
This guide is the first hour, sequenced. It assumes an agent that calls tools — the shape matters more than the framework — and it ends with the three verifications that tell you the trail is real: a chain that verifies, a replay you can walk, and a question the ledger can answer.
What is the recording call? the single integration point through which an agent reports each action to the ledger: a POST to the actions API with a Bearer API key, carrying the agent_id, action type, tool name, input and output summaries, and metadata. Everything else in the system — chaining, verification, replay, alerts — is downstream of this call happening for every action, which is why the integration guidance is always the same: wrap the tool-execution point once, rather than sprinkling calls through the codebase.
Step one: enroll the agent as an identity
Create the workspace and enroll the agent under a name that will still make sense in a hearing: role and environment, not the sprint codename. The enrollment issues the agent's API key — its identity credential — and opens its ledger stream. Treat the key like any production secret: in the secret manager, scoped to this agent, never shared with a second agent even 'temporarily'. Two agents sharing a key is the first forensic failure, committed on day one, usually by a reasonable person in a hurry.
Write the agent's mandate in the enrollment notes while it is fresh: what it may do, its caps, its escalation path. Three sentences now save a deposition later, and the founding record of the ledger is the right place for them to live.
Step two: one wrapper at the tool-execution point
Find the single place where your agent's tool calls execute — the dispatcher, the tool runner, the framework's executor hook — and wrap it: before or as the call executes, emit the action record; when the result returns, the outcome rides with it. One wrapper gives you every tool, including the ones added next quarter, which is the entire point. Per-tool instrumentation is how coverage goes to die.
The record's fields, in the order investigators will want them: agent_id from the key, action type and tool name, the input summary (masked — decide the masking per tool now, while the list is short), the output summary, the outcome, and token counts where your framework exposes them. The server appends the record to the chain and returns its sequence and hash; log that pair in your own traces as the cross-reference between your observability and your evidence.
Step three: the capture policy, on one page
Before the second agent arrives, write the one-page capture policy: per tool, which argument fields appear in summaries, which are masked to last-four or tokenized, and what never gets recorded. Add the reasoning rule — the agent states a one-or-two-sentence basis for consequential actions, in categories rather than quotations — and wire it into the agent's instructions. An hour of policy now prevents the two failure modes that retrofits cannot fix: summaries too thin to investigate with, and a ledger quietly full of raw personal data.
Step four: prove it three ways
Run the chain verification over the agent's first records and watch it pass — the gesture matters, because it converts 'we installed logging' into 'the evidence verifies', and the team's mental model shifts accordingly. Open the replay of a real run and walk it: can you follow what the agent did and why, step by step, from the records alone? Then ask the ledger a question you actually care about — every action above a threshold this week, the first use of a given tool — and confirm the answer arrives with citations. Three checks, ten minutes, and you know which of the system's promises are real in your stack.
Finally, set the two calendar habits while motivation is high: monthly verification (with the result filed) and, when you move to a paid tier, period-close certificates. Controls installed in the same week as the system become culture; controls scheduled for later become archaeology.
Five actions you must take today
The whole getting-started motion, compressed:
- Enroll one agent — the most consequential one. Its own key, its mandate written in three sentences, the key in the secret manager.
- Wrap the tool dispatcher once. Every tool, present and future, recorded from the single execution point — never per-tool sprinkling.
- Write the one-page capture policy. Masking per tool, summaries with amounts and masked IDs, reasoning in categories — before the second agent exists.
- Prove it three ways. Verification PASS, a replay walked end-to-end, and one real question answered with citations.
- Set the calendar habits today. Monthly verification filed; anomaly alerts on for bursts, first-seen tools, and after-hours spikes from the first week.
Worked example: a first week in numbers
A fictional two-person startup, InboxPilot, enrolled its email-triage agent on a Monday afternoon. Integration was one wrapper in the agent's tool runner — about forty lines — and the capture policy took one page: senders tokenized, subject lines out, action summaries carrying folder, label, and confidence category. By Friday the ledger held 3,912 records; verification passed; the founder walked the replay of a mislabeled thread and found, at step 14, the exact reasoning line that explained the misclassification — a debugging win before any audit ever asked.
The free tier's 1,000-action month would not have carried this agent's volume past the first week, and that is the honest shape of the free tier: enough to prove the pattern end-to-end on a real agent — chain, replay, interrogation, alerts — and to make the upgrade decision with evidence instead of forecasts. InboxPilot upgraded with the argument already won: the first week's records were the demo.
FAQ
What does the free tier actually include?
One agent and 1,000 recorded actions a month, with the core evidence machinery: the hash-chained ledger, chain verification, the timeline and replay, and the public verifier for exported records. Exports, alerts at scale, Tamper-Seal certificates, the causality graph and Ask the Tape interrogation sit on the paid tiers (Pro $49, Team $149) — the free tier's job is to let the pattern prove itself on a real agent before money enters the conversation.
How long does integration really take?
For a typical framework agent, the wrapper is an afternoon including the capture-policy decisions; the enrollment itself is minutes. The long pole is never code — it is deciding summaries and masking per tool, which is a one-page exercise for a first agent. Teams that quote weeks are usually describing a multi-agent rollout with reviews, which is a fine second phase; the first agent should still ship today.
Which agent should we enroll first?
The one whose incident would hurt most: money-moving, customer-messaging, or data-changing, in that rough order. Not the most complex agent and not the safest — the point of the first enrollment is that its history starts accruing before its worst day, and consequential agents are the ones whose worst days get investigated by other people.
What if our agent is built on a framework with its own tracing?
Keep the tracing for debugging and add the recording call at the tool-execution point for evidence. The two systems answer different questions (see our observability comparison), and the integration is one wrapper precisely because the framework already centralizes tool execution. Cross-reference the ledger sequence into your traces so investigations can travel between them.
When should we move to a paid tier?
When any of three lines is crossed: a second consequential agent enrolls, the action volume outgrows the free tier's 1,000 a month, or the first external audience appears — an enterprise review, an audit, a customer asking the evidence question. The paid features map to those moments: exports and alerts for operations, certificates and causality for external scrutiny. Upgrading early is cheap insurance; upgrading after the first external question is a negotiation with a clock.
Start logging your agents free → The free tier gives you the full hash-chained ledger for 1 agent and 1,000 actions a month, with chain verification and replay included.