Software Forgets: Agent Traces Are the Memory
Most of the work gets compressed into a commit message and a PR description. Sometimes a doc nobody updates again. The rest stays in someone's head, until that person leaves or simply forgets.
The tools we've tried for keeping context alive (comments, docs, blame, wikis, decision logs) all need someone to maintain them. That maintenance is glue work, and glue work usually loses to feature work. Meanwhile, more and more of the conversations that would have produced that context now happen privately, between an engineer and an agent.
And the audience for that context has gotten bigger. The on-call investigating last night's incident is increasingly an agent. The planner picking up a refactor is increasingly an agent. They can read 10k lines of context in seconds, but only if someone kept it.
What's interesting about agents is that they already produce that context as a byproduct. The agent searches the codebase, tries a few approaches, hits errors, reads docs, changes direction. It's all there. It's just sitting in a JSONL file on your machine.
As codebases become more autonomous and self-maintaining, agent traces become the densest record of the decisions that shaped them.
Give It a Home
Everything else has a home. Code is in git, docs in Notion, issues in Linear, chats in Slack. Agent traces don't have one.
Where does the failed Codex run from yesterday live? Where does the trace that produced the migration in PR #428 live? Where does the research thread that decided "let's use SQLite for this" live?
Usually: someone's laptop. Maybe a conversation in Slack.
Ours lives in a bucket. The Slack coding agent we run internally at Hugging Face sits on top of one on the Hub. Each session writes to it, and the agent can pull from past ones for memory.
Once every session lives in the same bucket, the agent gets a memory layer for free. A PR can link back to the trace that produced it, so the next reviewer (human or agent) can see how the change actually came together.
Start Here
At Hugging Face we want building with agents to be easy. Buckets are a big primitive in that direction: very generous storage pricing, with a clean DX through the hf CLI for syncing and managing your data.
Create the bucket, then sync whatever agents you're running:
# Create a private bucket for all your sessions
hf buckets create agent-sessions --private
# Claude Code
hf sync ~/.claude/projects/ hf://buckets/{username}/agent-sessions/claude
# Codex CLI
hf sync ~/.codex/sessions/ hf://buckets/{username}/agent-sessions/codex
# A Pi running a small agent at home
hf sync ~/.pi/agent/sessions/ hf://buckets/{username}/agent-sessions/pi
The agent trace viewer reads JSONL straight out of a bucket. Drop a trace in and you can open it.
Given that agents already record the messy path to a change, we should give that context somewhere durable to live. That way the next person, or the next agent, is not starting from whatever made it into the PR description.