What the agent always sees: a live map of its workspace
ReAct — KDCube's resident agent — gets a sharper picture of its own disposable, distributed workspace: a live view that shows what is local right now versus what it must pull first, so it stops tripping over objects it should have fetched.
KDCube is an agentic platform — an app can run many agents: build your own, bring Claude Code, or mix them. ReAct is our resident agent, the one we ship and run ourselves: built to work robustly in a distributed, isolated runtime, with its own skills, tools, and a real file workspace. Apps aren't forced onto it — it's just the agent we make first-class. Today's entry is about a small improvement to how ReAct understands and controls that workspace.
Inside a conversation it works in turns, and inside a turn it takes small steps: act, see the result, then decide the next move. To do real work it reads files, edits them, and runs code. Two facts make its workspace tricky, and one simple rule makes it safe.
Fact 1 — the workspace is rebuilt every turn
Every turn can start on a different machine with an empty workspace. The only thing carried in is the conversation timeline (which we cache). So nothing you produced last turn is sitting on disk now — only a reference to it survives across turns.
Fact 2 — the workspace is semantically rich, not a flat folder
The agent doesn't see one undifferentiated folder. It understands kinds of workspace — each with its own meaning, storage, and lifecycle — and puts each thing where it belongs:
Knowing that a project belongs in versioned files/ while a one-off export
belongs in outputs/ is part of the agent's competence — that's
control, not just storage.
The one rule — pull first
Because every reference is virtual until you ask, to use anything you first
pull it. That turns a pointer into real local bytes for this turn —
even for proxies. Only then can the agent work with it:
A logical ref (fi:…, cnv:…, an event, an attachment) is only
a pointer. pull makes it real and local. read brings it
into the agent's timeline as blocks it can actually see; checkout gives it an
editable copy in the current turn; code execution lets it work with it like a filesystem.
All three need the bytes to be local — so they all start with a pull.
The live view — always in front of the agent
The timeline is the durable, cached record of the conversation. But some things change every single round and must not be cached: the budget, live user interrupts, and what is in the workspace right now. So the agent keeps a small, always-on live view in front of it — a designated area of heightened attention for the immediate, volatile signals it must not lose track of, recomputed each round.
Where the live view sits
Everything the agent sees arrives as one ordered input. First a stable envelope: its instructions, then the catalog of tools it can call and the skills it can run. Then the timeline of events, oldest → newest — history, this turn's request, and the progress so far. And always at the very tail, the live view.
The agent knows its attention board — the volatile, immediate signals — lives there, last, on every round. The front of the input is stable and cacheable; the live view is recomputed each round, so it can change between rounds, not just between turns.
What we improved today
The live view now shows the agent a live map of its workspace, in two halves:
- LOCAL — exactly what is materialized on disk this turn. If it's here, the agent just reads or edits it.
- REMOTE — the top-level projects from its latest committed work, ready to pull, with a single anchor that tells it precisely how to build the pull link for any of them.
Before, the agent could see a reference to a file it made last turn and wrongly assume it was still on disk — then fail the moment it tried to use it. Now it can tell at a glance what is already local versus what it still has to pull, so it pulls before it reads, edits, or runs code — and stops tripping over the very objects it should have fetched first.
Documentation on GitHub
The live docs behind this entry: