Direct answer
AI agent session log
An AI agent session log is the record of one sitting: what was asked, what ran, what came back, in order. Every client keeps some version of it, a transcript, an app history, a terminal scrollback, and every version is either locked inside the tool or kept by the person it describes. This page covers the checkable version: a session log built from verifiable receipts, which survives the session, can be handed to the next one, and can be recomputed by anyone, free.
Updated October 20, 2026.
The honest starting point: a transcript is a story about the session
A transcript records what was said. A session log should record what was done, and the distance between the two is where disputes live: the agent said the tests passed, the transcript shows it saying so, and nothing in the transcript lets anyone check whether a test ran at all, what it returned, or whether the result shown is the result from that session. Transcripts also decay as evidence in ordinary ways: they are edited when cleaned up for sharing, truncated when exported, and stranded when the tool changes. A session log built from receipts keeps the doing, each call's inputs and saved result fixed at run time, and treats the talking as context around it.
What a session entry must hold
The same five atoms as every record on this hub: the tool, the exact inputs, the saved result as it came back, the time, and the fingerprint over the result, with the entries chained in the order the session actually ran. Two session-specific points matter. First, failures belong in the log: the errored call and the retry are what make the eventual success readable, and a session log with the failures trimmed is a story again. Second, the log should end where the session ended, with the open steps named as open; that honesty is what lets the next session, human or AI, pick up from the record instead of from a summary of it.
The session log, client by client
Every AI client keeps some version of a session log. What follows is the honest tour: what each one gives you today, and the one thing none of them give you, a record a stranger can recompute. Read the tour with the morning-after question in mind: the session is closed, the tab is gone, and a reviewer asks what happened in it. Which record answers?
ChatGPT session log
The session log ChatGPT gives you today is a conversation history and a memory view inside the account, both written for the person chatting, in the vendor's format, behind the vendor's login. As a session log for ChatGPT work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Claude session log
The session log Claude gives you today is project and conversation history inside the account, tidy and readable, and entirely the platform's own account of what happened. As a session log for Claude work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Claude Code session log
The session log Claude Code gives you today is terminal transcripts and session files on your own machine, detailed and genuinely useful, and kept by the same person whose work they describe. As a session log for Claude Code work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Codex session log
The session log Codex gives you today is run history inside the product, a transcript of what the agent reported, readable by the account holder and no one else by default. As a session log for Codex work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Copilot session log
The session log Copilot gives you today is the thinnest native record of any client here: suggestions appear inline in the editor and mostly vanish into the code, with no per-step history at all. As a session log for Copilot work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Cursor session log
The session log Cursor gives you today is chat and composer history inside the editor app, tied to the workspace, and gone as evidence the moment someone asks from outside the app. As a session log for Cursor work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Gemini session log
The session log Gemini gives you today is conversation history inside the account, or session files for CLI work, both readable and both self-kept in the way that matters here. As a session log for Gemini work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Grok session log
The session log Grok gives you today is conversation history inside the account, with nothing per-call underneath it that a second person could open. As a session log for Grok work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
n8n session log
The session log n8n gives you today is an execution history inside your own n8n instance, a real log with real detail, and, like every log, editable by whoever operates the instance. As a session log for n8n work that someone else has to trust, it fails the same test every self-kept record fails: the reader must trust the keeper. Route the same work through the Zambo MCP at https://zambo.dev/mcp and each call leaves a verifiable receipt as it runs, so the session log for that work is no longer a view inside one account. It is a chain of records anyone can check free at zambo.dev/verify, which is the difference between showing someone your history and handing them evidence.
Session log by situation: API access, audiences, and the free route
Through an API. Sessions are the unit teams actually review, so session records are the ones worth fetching programmatically. A program can pull a job's receipts, recompute each fingerprint, and report which steps check out, which is how a session log API earns its keep for developers: the audit becomes a script, not a reading session. For freelancers and small business, the session log is delivery evidence: the record behind an invoice that a client can check alone. For teams and agencies, it is the shared version of events that ends arguments between timezones and between firms. For clients, it is the rare record they can verify without an account on your tools. The format underneath is AER-1, a public IETF Internet-Draft with an open conformance kit, so none of this depends on one vendor's export surviving; independent checkers can read the same record. Checking is free, always, and the best session log by the standard this hub applies is the one minted during the work, complete with its gaps showing, rather than the one assembled afterward with them edited out.
Worked example: one real recorded call
Receipt 588f5158-e335-4ba8-9009-72fad8410d55: tool live_price, executed 2026-09-21, result a Bitcoin price quote, with a SHA-256 digest over the saved result. Open the receipt and recompute the digest, or run it through zambo.dev/verify/: the receipt lets anyone check the saved result was not changed since it was saved. One call is one line of history; a job is a chain of them.
Honest limits
A receipt-based session log covers the calls that ran through the record during that sitting. Thinking, drafting, and any tool use outside the connection leave no entry, and the log is more believable for showing that boundary than for hiding it. The log also proves integrity, not quality: it establishes what ran and what came back, unchanged since, and the judgment about whether the session did good work stays with the reader, now working from facts that check out.
Frequently asked questions
What is an AI agent session log?
It is the record of one working session with an agent: the calls made, their inputs, their saved results, and their order, kept so the session can be reviewed after it ends. In its strong form each entry is a verifiable receipt with a fingerprint fixed at run time, so a reviewer can recompute any entry free at zambo.dev/verify. A transcript records what was said in the session; a session log records what was done, and lets others check it.
How is a session log different from a chat transcript?
A transcript is the conversation, including the agent's claims about its own work, kept by the platform or the user, and editable in every practical sense. A session log is the work: tool calls with inputs and saved results, each fixed by a fingerprint when it ran. When the agent says a step succeeded, the transcript gives you the sentence and the log gives you the result the sentence was about, checkable by someone who was never in the chat.
Does Cursor keep a session log?
Cursor keeps chat and composer history inside the editor, tied to your workspace, which is useful while you are in the app and weak as a record for anyone outside it. For a Cursor session log a lead or a client can check, route the session's tool work through the Zambo MCP at https://zambo.dev/mcp; each call leaves a receipt, and the chain is the session log in portable, checkable form.
Can I hand a session log to the next session?
Yes, and it is one of the best uses. Gather the session's receipts into a handover at zambo.dev/handover and open it in the next session, whichever client runs it. The new session reads what actually ran and what came back, including the failures and the open steps, instead of a summary written for politeness. That is how a session log stops being an archive and becomes working memory.
How much does an AI agent session log cost?
Checking any entry is free at zambo.dev/verify. Recording a session starts inside the daily free allowance on Zambo's metered tools, a Day Pass covers 24 hours of full access for $0.99, and the Zambo Pass is $29 a month or $290 a year, with a $19 a month holder tier. Sessions are usually a few dozen calls; the free allowance covers more real sessions than people expect.