Published 18 November 2026. Product behaviour, retention periods and deletion timings below were read from each vendor's own pages on 18 November 2026.
An agent trace is the record of what happened in one run: the instructions, prompts, retrieval queries, tool calls, intermediate reasoning, outputs, latency and cost. Agent memory is what you decided to keep from those runs, written as small statements about a person or the world, with conflicts resolved, a scope that says whose it is, an owner who can change it, and a way to delete one person's facts on request. A trace is evidence, and memory is a decision made about that evidence, which is why a bucket of every trace your agent ever produced is neither learning nor a memory you can govern.
Four announcements on 16 and 17 November 2026 put traces at the centre of agent infrastructure. On 16 November Guillermo Rauch wrote on X that he believes "Traces are the essential new primitive of software development and agentic evolution", quoting the news that Traces is joining Vercel, and the same day Clem Delangue announced that Hugging Face and OpenRouter users can store OpenRouter agent traces on Hugging Face "to inspect them, train better models or share them with the world". On 17 November LangChain shipped controls for sensitive data in LangSmith traces, naming names, health information and payment details as the customer data traces hold, and Langfuse began logging who reads traces, not only who changes them. Traces are becoming a first-class asset, which raises the cost of two common mistakes: treating the trace store as the agent's memory, and treating access control on traces as if it removed a person from them.
Agent traces vs agent memory, side by side
| Agent trace | Agent memory | |
|---|---|---|
| What it is | A record of one run: inputs, outputs, tool calls, reasoning, timings, cost | Statements kept from many runs about a person, an account or the world |
| Unit | A run tree or span tree, often thousands of tokens | One self-contained fact, preference or event, often one sentence |
| Written when | Automatically, every run | Deliberately, when something is judged worth keeping |
| Changes after writing | Never; it is a log of what happened | Yes; a newer fact supersedes an older one, duplicates merge |
| Conflicts | Kept side by side (March says Boston, September says Austin) | Resolved, with the old version marked historical |
| Scope | Usually a project or workspace, sometimes tagged with a user ID | A user, a customer, an agent or a conversation, by design |
| Main reader | Engineers debugging and evaluating runs | The agent, at the start of the next run |
| Default lifetime | Set by the trace platform's retention tier | As long as the fact stays true and the person has not asked for erasure |
| Personal data | Whatever the user typed and the tools returned, unfiltered | Only what passed a write-time decision about what to keep |
| Deletion unit | Trace IDs, or traces matching a metadata filter | One person, across every derived fact, summary and embedding |
The right column is harder to build, and that is the point. A trace costs nothing to decide, because it keeps everything. Memory costs a decision on every write, and those decisions (what to extract, what it replaces, whose it is, how long it lives) are what make an agent behave differently next time.
Are agent traces memory?
Traces are raw material for memory, and a trace store that the agent can query is a working form of episodic recall, but it is not long-term memory in the sense that matters for an agent serving people. The case for "traces are the memory" is real, and it deserves a precise concession. Hugging Face's Software Forgets: Agent Traces Are the Memory (19 May 2026) describes storing its internal Slack coding agent's sessions in a Hub bucket where the agent can pull past sessions back as memory, and puts it as "Once every session lives in the same bucket, the agent gets a memory layer for free." For a coding agent that wants to know why a change was made last month, that works, because the codebase is one shared world, the sessions describe it, and an old session rarely contradicts a newer one about a person.
Deeplake draws the line between observability tools, which serve humans with dashboards and debugging, and trace storage that agents read at inference time, and says you usually want both. Cognee's session traces are the most careful version of the idea: each trace records a function's name, parameters, status and return value or error, stays in a session cache scoped by session_id, and does not enter the permanent knowledge graph unless you promote it with improve(session_ids=...) or with persist_session_trace_after=N on the decorator. That promotion step is the whole difference between a trace and a memory, and Cognee makes it explicit.
Raw traces break as memory in three places once the agent serves people over months:
- Conflicts stay unresolved. A user who lived in Boston in March and moved to Austin in September has both statements in the trace store, and similarity search returns whichever chunk scores higher. Nothing in a trace says which one is current, because a trace is a faithful log of what was said, including what has since stopped being true. Our post on agent memory consolidation walks through this exact case.
- Scope is an afterthought. Traces are organised by project, workspace, session or run. Asking "everything we know about this person, across every agent and every run" means the user ID had to be attached at write time on every trace, and nothing in the trace format requires it.
- The signal is a tiny fraction of the tokens. A run tree for one support conversation carries system prompts, retrieved documents, tool payloads and retries. The durable fact inside it ("prefers invoices in euros") is a few words. Retrieving over the run tree puts all the rest back into the context window.
The survey of evidence tracing and execution provenance in LLM agents (arXiv 2606.04990) makes the same split from the research side: it defines agent traces as "the recorded artifacts generated or consumed during an agent run", treats memory items as objects with an origin, revisions and validity conditions, and argues that most memory systems do not track that lineage.
Traces are also not the same thing as agent state. A checkpoint lets one run resume; a trace records what that run did; memory carries facts across runs. The agent state vs agent memory post covers the checkpoint side.
Storing every trace is not learning
An agent learns when its behaviour on the next run changes because of something that happened on an earlier one, and storage alone changes nothing. Rauch's own post describes two steps, not one: first you "securely capture" your traces, and "Then, set up the recursively self-improving systems based on the learnings they contain: friction, latency, outcomes." The second step is where the work is, and a trace bucket does not do it for you.
Turning traces into memory is a write path with five decisions on it:
- Select. Most runs contain nothing worth keeping about the user. A promotion job reads traces and keeps only what is likely to matter on a later run.
- Extract. Pull the durable statement out of the run tree as a self-contained sentence with a type, a timestamp for when the thing happened, and a confidence.
- Resolve. Compare it against what is already stored and decide whether it supersedes, duplicates or enriches an existing memory, or is new. This is the step that fixes Boston and Austin.
- Scope. Attach it to the user, customer, agent or conversation it belongs to, so it is retrieved only where it should be and can be erased with that person.
- Minimise. Drop what should never be stored as memory at all, such as card numbers, security codes and passwords that appeared in a tool payload.
That job usually runs in the background, which is what Anthropic calls dreaming: its diagram, described in our consolidation post, has dreaming read the transcripts at the bottom layer and write to the memory layers above them. The transcripts stay as evidence, and the agent reads the layers above. Traces in, governed memory out, is the same architecture with the trace store as the bottom layer.
Traces carry personal data, by design
LLM traces contain personal data whenever the agent talks to people, because a trace stores the user's messages and the model's responses at full fidelity. LangChain's 17 November post says it plainly: "Trace inputs and outputs are where sensitive user data most often resides", and it names GDPR, HIPAA and CCPA as the regulations that make companies liable when that data leaks. Tool calls add more, because whatever a CRM lookup, a billing tool or a clinical intake form returns is recorded in the span that called it.
The new LangSmith controls, available on Enterprise plans, are three layers of access control on that data:
- Input and output access controls let admins hide the user messages and model responses while engineers still see run trees, latency, cost and token usage.
- User groups set data access per group, per workspace, on top of existing role-based and attribute-based access control. LangChain's example is clinicians who can read inputs and outputs for annotation while agent engineers see only run trees, latency and token usage.
- Trace-level policies on root run metadata grant access when a trace's metadata matches a condition, such as a customer ID for a support agent.
Harrison Chase's description of the workflow on 17 November is the sensible default: trace everything, restrict inputs and outputs, and "when a customer complains, get their permission and enable a small set of engineers to see inputs/outputs for their bad traces." Langfuse's read-access audit logs, shipped the same day, record who opened, listed, searched, exported or downloaded traces, observations, scores, sessions and experiments, including through the API and MCP tools. They are available on Langfuse Cloud Enterprise, always on for Langfuse Cloud HIPAA, and on self-hosted Enterprise from v4.82.0.
All of this is good engineering, and none of it removes anyone. LangChain's post says LangSmith "stores the complete traces without requiring redacted or duplicate copies", which is exactly what you want for debugging and exactly why access control and erasure are separate jobs.
Access control on traces is not erasure
Hiding a person's messages from engineers controls who can read them; erasure removes them. Article 17(1) of the GDPR gives a data subject the right to have their personal data erased "without undue delay" when, among other grounds, the data is no longer needed or consent is withdrawn. A trace whose inputs are hidden from the engineering group still holds the person's name, health details and payment fragments, still sits inside its retention window, and still feeds every dataset, eval set and memory job that read it.
Erasing a person from traces is possible on both major platforms, but it has to be done deliberately, and it only works if you can find their traces:
- LangSmith deletes traces either by a list of trace IDs with their project's session ID (up to 1,000 traces per request) or by matching any metadata key-value pair across a workspace. Deletion is "not instant": LangChain says traces may become unqueryable right away and most deletes are hardened within 6 hours, and the delete also removes related feedback, aggregations and stats.
- Langfuse deletes traces one at a time, in batches, or by a filter in the trace list. Deletion is asynchronous, usually within 15 minutes, with no confirmation, so you verify by querying again. Langfuse states that trace deletion "does not remove personal data that may also be stored in other objects, such as datasets."
Retention decides how long traces sit there if nobody deletes them. LangSmith has a base tier of 14 days and an extended tier of 400 days, and a trace moves to extended retention automatically when it receives feedback (from a person or an automated evaluator), matches a run rule, or is added to an annotation queue. The trace a customer complained about is therefore the one most likely to be kept for 400 days. Copying a trace into a dataset does not upgrade it, because the dataset copy is a separate object with its own life. Langfuse data retention is set per project in days with a 3-day minimum, on Pro and Enterprise plans; it deletes traces, observations, scores and media nightly, does not touch audit logs or dataset items, and without a policy nothing is deleted automatically.
So a request to erase one user reaches at least five places: the trace store, every dataset and eval set built from those traces, annotation queues, any memory store a promotion job wrote to (including its embeddings and summaries), and any copy you pushed somewhere else, such as a trace repository shared for training. Our guide to GDPR-compliant agent memory covers the memory side, including backups.
Provenance and erasure pull in opposite directions
Memory should point back to the trace it came from, so you can answer "why does the agent believe this?", and traces should expire quickly, so personal data does not sit in a debugging tool for 400 days. Both are right, and they collide when a memory's provenance link points at a trace that retention has already deleted.
The way through is to decide what provenance needs and store that with the memory: the trace ID and timestamp for audit, plus the short verbatim excerpt the fact was extracted from, kept under the same scope as the memory. When the person asks to be erased, the memory, its excerpt and its embeddings go together, and the raw trace has already gone or goes in the same job. When the trace expires on schedule, the memory still explains itself.
Traces in, governed memory out: a checklist
- Put a stable user ID (pseudonymous if you can) and a tenant ID in the root run metadata of every trace. Both LangSmith's metadata delete and its access policies depend on it, and so does finding a person's traces later.
- Restrict trace inputs and outputs by default, and open them per incident with the customer's permission.
- Keep raw traces on the shortest retention tier your debugging allows, and know which actions extend it.
- Run a promotion job that selects, extracts, resolves, scopes and minimises before anything becomes memory. Never point the agent at the raw trace store for facts about a person.
- Store provenance with each memory (trace ID plus source excerpt) so it survives trace expiry.
- Build one erasure job per person that covers traces, datasets, eval sets, annotation queues, memory, embeddings and any exported copies, and verify each by querying again.
- Before sharing or publishing traces for training, check them for personal data the same way you would a database dump.
Where Maximem Synap fits
Maximem Synap sits on the memory side of this line. It reads the conversation as it arrives and decides what is worth keeping, then keeps that, not the transcript: self-contained statements with a type, a confidence score, a scope and when the thing described actually happened. Every memory can be traced (where it came from, what it replaced, why it changed and what it used to say), the verbatim source text behind a returned memory comes back as source evidence, and erasure is per person, previewed before it runs. Payment card details, security codes, PINs, passwords, API keys, private keys and raw biometric data are never stored, for any customer. Your traces stay in your tracing tool; Synap is the governed memory built from the conversations you send it.
Frequently asked questions
Are agent traces the same as agent memory?
No. A trace is an unedited record of one run, and agent memory is the set of statements kept from many runs, with conflicts resolved, a scope and a deletion path. A trace store the agent can search is a form of episodic recall, but it returns old and new versions of a fact side by side and has no notion of whose fact it is unless you tagged every trace.
Can an agent learn from its traces?
It can, but only through a step that reads the traces and changes something: memory written by a promotion or consolidation job, a prompt or skill updated from failure patterns, or training data for a model. Storing traces enables learning; it is not learning by itself.
Do LLM traces contain personal data?
Usually, if the agent talks to people. Traces store user messages, model responses and tool outputs at full fidelity, and LangChain's 17 November 2026 post names names, health information and payment details as the sensitive customer data traces hold.
Does hiding trace inputs from engineers satisfy a GDPR erasure request?
No. Access control limits who can read the data; Article 17 requires the data to be erased without undue delay. You need to delete the person's traces and every copy derived from them, including datasets and memory.
How long do LangSmith and Langfuse keep traces?
As of 18 November 2026, LangSmith keeps traces for 14 days on base retention and 400 days on extended retention, and feedback, run rules or annotation queues upgrade a trace to extended. Langfuse keeps data until you delete it unless you set a per-project retention period (minimum 3 days, Pro and Enterprise plans).
How do I delete one user's traces?
Tag every trace with a user ID in metadata, then delete by that metadata (LangSmith) or by a filter in the trace list (Langfuse). Expect it to take minutes to hours, verify by querying again, and delete the same person from datasets and memory separately.
Sources
All retrieved 18 November 2026.
- LangChain, Protect sensitive data in your traces: new controls in LangSmith, 17 November 2026
- Langfuse, Read-access audit logs, 17 November 2026
- LangSmith docs, Data purging for compliance
- LangChain support, Why are my traces being automatically upgraded to extended retention?
- Langfuse docs, Data deletion and Data retention
- GDPR, Article 17, right to erasure
- Hugging Face, Software Forgets: Agent Traces Are the Memory, 19 May 2026
- Deeplake, Agent observability vs agent trace storage, 29 April 2026
- Cognee docs, Agent session traces
- Wang et al., From Agent Traces to Trust: A Survey of Evidence Tracing and Execution Provenance in LLM Agents, arXiv 2606.04990
- Posts on X by Guillermo Rauch (16 November 2026), Clem Delangue (16 November 2026) and Harrison Chase (17 November 2026)



