There is a specific kind of fatigue that comes from agentic coding, and it is not the fatigue of writing prompts. It is the fatigue of archaeology — scrolling back through a closed chat to figure out which report_v3_final.md was built from the source you actually trust, whether the last "done" meant saved or reviewed or sent, and which checks were promised but never run.
Retulo, an MIT-licensed Python CLI paired with an MCP server, is a direct answer to that fatigue. Its premise is narrow and useful: file-producing tasks deserve a durable local workspace that holds task identity, source material, output versions, recorded decisions, remaining work, and checks — so that a new conversation does not mean reconstructing the work from a transcript. Setup is documented for both Codex and Claude Code, which tells you where the author expects this to be used: inside agentic coding loops, not standalone.
What follows is an analysis of the mechanism, the trade-offs that come with it, and the conditions under which it is worth the operational overhead.
Why chat transcripts make a poor file system
Conversational agents are stateless by design and stateful by accident. The transcript becomes the de facto record, which creates three structural problems.
Ambiguity of referent. When a user says "use the latest source," the agent resolves that against whatever is in the context window. Close the tab and reopen tomorrow, and the same sentence resolves differently — or fails to resolve at all. The file exists; the provenance does not.
Loss of decision rationale. An agent that chose one formatting library over another, or one schema over another, leaves that reasoning in prose buried three turns deep. The next session re-derives it, often differently, which is a silent source of churn in long-running work.
Unverifiable completion. "Done" is the most overloaded word in agent output. Was the file written? Reviewed? Did the validation step actually execute, or was it described as if it had? Transcripts record assertions, not evidence.

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: dev.to
Retulo's bet is that these are not prompt problems. They are missing-infrastructure problems, and the fix looks less like a smarter model and more like a small, boring, local data store with a schema.
What Retulo actually does
Task identity as the anchor
The central abstraction is a task, not a chat and not a file. A task owns a workspace on disk. Source material goes in, outputs come out, and both stay attached to the same identity across sessions, across tools, and — critically — across model changes. If you swap from one agent CLI to another mid-stream, the task survives; only the interface changed.
This is the right level of granularity. Files are too fine-grained (you end up with a version graph nobody reads), and projects are too coarse (you lose the ability to say "this specific deliverable is complete").
Versions, decisions, and checks as first-class records
The workspace is not just a folder. It carries structured entries for:
- Output versions, so that "the latest" has a definition that does not depend on the context window.
- Recorded decisions, so that rationale is retrievable rather than re-derived.
- Remaining work, so that an interrupted task has an explicit queue instead of an implied one.
- Checks, so that verification is a named obligation rather than a vibe.
The checks concept is the most consequential and the least glamorous. An agent that records "this still needs to run" is producing an auditable open loop. An agent that records "this passed" is producing a claim. The value depends entirely on whether the tool enforces the difference — and that is where implementations typically leak.
MCP as the integration surface
The choice of MCP is the architecturally interesting part. Rather than writing bespoke integrations per agent product, Retulo exposes its workspace operations as MCP tools, and any MCP-capable client can drive it. That is a genuine decoupling: the store outlives the agent that populated it.
The cost is that the workspace schema becomes a public contract. Once Codex and Claude Code and whatever ships next quarter all read and write the same records, changing the shape of a decision entry is a breaking change for everyone. Early-stage schemas tend to be under-specified; here, under-specification is a compatibility liability rather than an inconvenience.

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: dev.to
The trade-offs nobody puts in the README
Write amplification and duplicated state
Every persistent agent workspace duplicates something the filesystem already knows. The directory tree holds files; the workspace holds a parallel narrative about those files. When the two diverge — a file edited outside the agent, a rename that bypasses the tool — the workspace becomes confidently wrong, which is worse than silent.
Mitigation is a discipline problem as much as a tooling problem. Teams need a rule about what happens when a human edits the output directly, and the honest answer is usually: the workspace must be invalidated or reconciled, and someone has to own that step.
Workspace sprawl
Local workspaces accumulate. A CLI that makes it cheap to start a task makes it cheap to start forty tasks, most of which die after one output. Without retention policy — archive after N days, collapse completed tasks, prune orphaned workspaces — the store becomes a graveyard that costs disk and, more importantly, attention.
The trust boundary moves inward
An MCP server with filesystem access is a capability grant. It reads source material and writes outputs, and it does so on behalf of a model that may be persuaded by content it ingested. Prompt injection through a document is a well-understood failure mode; a workspace that intentionally ingests documents is a natural amplifier. Directory scoping, explicit allowlists, and refusing to follow instructions found inside task content are not optional hardening — they are the price of the model having hands.
Ceremony versus speed
Every record-keeping layer taxes the fast path. The reason chat-based file work is popular is that it is frictionless: ask, receive, move on. Retulo asks for a task to be opened, decisions to be logged, checks to be declared. For a one-off script, that is pure overhead. The tool only pays for itself when the work has a lifespan measured in days and a review process measured in people.
Who actually benefits
Strong fit: engineers running multi-session deliverables — migrations, audits, generated documentation sets, data pipelines with staged reviews — where the same artifact is touched by different agents on different days. Also strong for teams that need a defensible record of what an agent produced and what was verified, because the workspace is local and inspectable rather than trapped in a vendor's history.
Weak fit: solo one-shot generation, exploratory prototyping, and anything where the artifact is disposable. Adding ceremony to throwaway work is how teams conclude that agent tooling is bureaucratic and go back to copy-pasting from chat.
Genuinely uncertain: regulated environments. Local, plain-text-adjacent state is a real advantage for auditability, but the same property means the workspace can contain sensitive source material with whatever access controls the filesystem provides — which is often none.
Risks worth naming
- Two sources of truth. If the workspace and the files disagree, agents will believe the workspace. Design the reconciliation path before you need it.
- Stale checks read as green checks. A check recorded as passed three versions ago is a hazard unless checks are bound to specific output versions.
- Schema lock-in. MCP standardizes the transport, not the semantics. Migrating a custom record format later is real work.
- False confidence in completion. Structured state can make a team feel audited without being audited. The record is only as good as the enforcement behind it.
A sane pilot
Pick one recurring deliverable with a two-week lifespan and two reviewers. Run it inside Retulo with three rules: checks are bound to a specific output version, any human edit to an output invalidates the workspace, and completed tasks are archived weekly. If the workspace is consulted more often than the transcript, it earned its place. If nobody opens it, you have learned something cheaper than a rollout.
Key takeaways
- Retulo targets a real gap: agents produce files well and remember them badly, and transcripts are a poor substitute for structured task state.
- The task-as-anchor abstraction, with versions, decisions, open work, and checks, is the correct granularity — finer becomes noise, coarser becomes unmanageable.
- MCP decouples the store from the agent, which is the durable win and the source of schema lock-in risk.
- The largest operational risks are divergence between workspace and filesystem, sprawl without retention policy, and prompt-injection exposure from ingesting untrusted documents.
- The tool is overhead for one-off work and leverage for multi-session deliverables with review steps.
Next steps
- Audit your last month of agent sessions and count how many required reconstructing context from a transcript. That number is your budget case.
- Trial Retulo on exactly one multi-session deliverable, with checks explicitly bound to output versions.
- Define a reconciliation rule for human edits to agent output before the first task starts, not after the first conflict.
- Scope the MCP server to a dedicated directory and treat every ingested document as untrusted input.
- Set a retention policy — archive cadence and orphan pruning — on day one, because you will not add it later.
Sources
- Retulo, MIT-licensed Python CLI and MCP server for agent file workspaces: https://dev.to/thestack_ai/retulo-keep-codex-and-claude-code-file-work-across-chats-1mje



