Poggle
Shared memory for your coding agents.
One agent hits a usage cap three hours in. The next one starts from zero — it does not know the goal, what already failed, or what is half-finished. Poggle logs what your agents do as they do it, so the next one picks up where the last one stopped.
The problem
Context dies with the session that produced it.
You run several coding agents against one repo — Claude Code on one plan, Codex on another, a teammate's Cursor. Three hours in, one hits a usage cap. You switch to the next one, and it knows nothing: not the goal, not which approach already failed twice, not that the migration was written but never run.
- CLAUDE.md and AGENTS.md
- Static and hand-maintained. They describe the repo, not what is happening in it right now, and nobody updates them mid-task.
- The agent's own context
- Dies with the process, and is compacted away long before that.
- --continue and --resume
- Same tool, same account, same machine. Useless the moment you switch plans or agents.
- Telling the next agent yourself
- You are the bottleneck, you are working from memory, and you forget.
1. Capture
Hooks log what your agents do, as they do it.
Claude Code already hands a hook every prompt, every tool call and the path to its full transcript. Poggle installs those hooks and listens: prompts, edits, commands, test runs, commits, decisions, blockers and caps, logged without anyone remembering to.
Codex, Cursor, CI and anything else reach the same log through a documented endpoint and a zero-dependency CLI. Events spool to disk before they are sent, so an agent killed mid-call still reports what it was doing.
How capture worksSession log / What the agent actually did
Every prompt, edit, command and decision, in order, with the ones that matter scored highest.
2. Hand off
The next agent starts knowing what the last one knew.
At session start, the next agent gets a brief — assembled from what came before, sized to a token budget, injected into its context before it reads a single file.
What survives a tight budget is what an agent would most regret not knowing: why the last session stopped, what is blocked and already failed, decisions taken, what was left half-applied. Files touched come last — an agent can read the repo, but it cannot recover a decision nobody wrote down.
What is in a briefHandoff brief / What the next agent reads first
Assembled from the sessions before it and sized to a token budget, injected before it opens a file.
3. Work together
Several agents on one repo, without collisions.
Agents check in as they work: stating what they are doing, seeing who else is here, and claiming the files they are about to change. When someone edits a file you claimed, you are told at your next check-in — a collision you hear about now is a merge conflict you do not get later.
Claims expire on their own, because an agent killed by a usage cap never releases anything. Webhooks carry the moments a human should see: an agent capped mid-task, two agents wanting the same file.
How coordination worksRoster / Three agents, one repository
Who is working, what they are touching, and which files are already claimed.
Built for what agents actually produce.
- smaller
- 93%A transcript is stored at a fraction of its size, keeping every piece of reasoning and cutting the tool output you can re-run.
- model calls per brief
- 0Brief assembly is deterministic. The same log and budget produce the same brief, byte for byte.
- hook budget
- ~2sEvery call is timeout-bounded and exits clean. A relay outage is invisible to the person coding.
Two commands, and the context carries itself.
Create a relay key, run poggle init in your repo, and start an agent. Everything after that is automatic.