To Give an Agent a Workspace: Laying a Foundation for Messy Forever Work

Alex Damis, organizer of Build The Future Orlando, presents a field-report-style talk arguing that AI agents require a structured, persistent workspace—not just a chat box—to handle real, long-running software work. Drawing on 18 months of iteration through two prior talks and daily experimentation, he introduces a three-layer workspace architecture (projects + roadmap + intel corpus), a ticket system designed as an agent's working memory, a skill-discovery loop for reusable workflows, a hive-mode parallelism pattern, and a vision for Gen 4 cloud-based agent pools.

Key Takeaways

Agents need a workspace, not just a project. Alex predicts all agents will ship with a workspace out of the box in the near future. 3:27
"Messy forever work needs semi-organized forever context." Real work builds on itself, gets interrupted, reveals more work, and never truly stops. 7:02
The workspace has three root folders: projects (delivery surfaces), roadmap (work memory via tickets), and corpus (company reality from the outside world). 3:53
Tickets are agent workspaces, not just status trackers—they hold diaries, artifacts, found work, specs, plans, and resolution proofs. 15:37
Skills are discovered, not designed. Let the agent log what it's learning during a run, then crystallize the muscle from those exercise logs. 50:03
Hive mode (parallelized sub-agent delegation) is the path to faster, deeper work; a single 1-hour task can decompose into parallel 20-minute subtasks. 1:03:22
The Intel Corpus separates work memory (tickets) from company reality (meetings, Slack, email, docs). A single meeting transcript can update all in-flight tickets at once. 1:11:06

Evolution from Earlier Approaches

Alex's workspace concept emerged from two prior talks. The first introduced a feature ledger—an append-only markdown file tracking decisions—which collapsed at 4,000–8,000 lines because agents could no longer make sense of it. 8:54 The second introduced an ask → plan → audit → build → verify loop and plan-MD contracts, which was valuable but lost the "idea maze" reasoning that led to each plan. 9:26

A month experimenting with OpenClaw and a "night shift" pattern (queuing tasks before sleep) revealed two further gaps: agents would mark tasks complete without actually finishing them 13:11, and they silently ignored bugs they noticed while working on something else 14:06. These failures motivated proof receipts and found-work tracking.

Ticket System as Agent Working Memory

The roadmap folder mirrors a Kanban board: inbox → in-progress → review → completed. Each ticket starts as a simple ticket.md with a description and goal. As work progresses it graduates from a file into a folder with sub-folders: 17:25

Folder	Purpose
`diaries/`	Tree-structured exploration logs (not linear—branches for side quests) 20:09
`artifacts/`	Inputs from the outside world + generated outputs, kept separate 21:31
`found-work/`	Circle-backs (revisit this ticket), spin-offs (new ticket), or inbox (TBD) 22:09
`specs/`	Large-scope contracts derived from "what we know" (WWK) consolidation diary 27:56
`plans/`	Plan-of-plans: phased mini-plans each passing ask → audit → red → build → green 28:07
`resolution/`	Final outcome, proof, follow-up work, verification receipts 22:54

ticket.md becomes a table of contents pointing to every file generated during the ticket's lifetime. 17:46 Discussion gates are explicit checkpoints where the agent pauses for human review before proceeding—critical for long autonomous runs where late-stage mistakes require discarding all downstream work. 28:55

The Launch Contract

Before a long autonomous run, Alex runs /setup to build a launch contract: goal, constraints (out-of-bounds areas), recommended tools, skills, proof definition, stop conditions, and return shape (the "landing package"). 32:51 When context compaction occurs mid-run, the agent's loop instructs it to re-read the launch contract, relevant skills, and its diary to re-orient—preventing context-loss derailment. 34:45

The landing package bundles what changed, why, what went weird, what remains, and proof assets (screenshots, GIFs, screen recordings), designed so the human can verify hours of work in minutes. 35:22

Skills as Reusable Workflow Memory

Alex advocates discovering skills rather than designing them upfront. 50:03 The mechanism:

/skill-lab — scaffolds an exercise folder and a muscle file inside the current ticket. 53:23
Exercise — the agent logs what it learned and where it struggled during the run. 52:01
Muscle — after the exercise ends, the agent updates the muscle with consolidated learning. 52:24
Skill promotion — after 2–4 runs, the muscle graduates into a global skill usable across all tickets. 53:53

Skills can be composed/chained (e.g., PR description → create PR → notify Slack → message reporter = ship flow). 56:20 Supporting slash commands include /vc (pick applicable skills automatically), /uc (targeted skill update), /clues (search other tickets' muscles for relevant prior art), and /nc (propose and approve a new skill on the fly). 57:30

Alex reports accumulating 140+ home-grown skills, updating ~5/day and creating 1–2/day, with occasional "10x unlocks" like the Intel Corpus or hive mode. 1:30:10

Hive Mode and Parallelism

Inspired by his boss's "waves skill," Alex distinguishes three levels of agent work: 1:03:22

Level 1: Agent does the work sequentially.
Level 2: Agent decomposes a 1-hour task into three 20-minute subtasks and delegates them.
Level 3: Small agent teams around each subtask—planner, workers, auditors—all parallelized.

The setup-and-delegate skill identifies work streams (front end, back end, data gathering), sorts tasks by near/medium/long-term horizon, resolves dependencies, and spawns sub-agents. 1:05:54 While sub-agents execute, the orchestrator is mostly idle and available for foreground mode—the human can keep chatting and planning the next wave while background agents implement the current one. 1:05:12

Alex notes he can accomplish roughly half a day's work in an hour with hive mode and believes Codex does not yet support sub-agents delegating to further sub-agents, but Ultra Code may. 1:03:46

Intel Corpus: Company Reality as Context

The Intel Corpus (the third workspace folder) is distinct from the roadmap: the roadmap remembers what was done on your machine; the corpus remembers company reality outside your machine. 1:11:45

Sources ingested: meeting transcripts, Gmail, Slack, Google Docs, customer feedback. 1:12:29 Meetings roll up: individual → daily themes → weekly themes → quarterly → annual narrative, giving the agent a persistent sense of organizational context. 1:12:41

A single sprint-planning call can affect eight in-flight tickets simultaneously—instead of manually re-explaining changes, Alex tells the agent to read the transcript and update all relevant tickets. 1:11:00 The corpus also enables larger analytical questions: "Did I move the needle this week?" or "Am I being a good manager?" 1:14:48

Alex distinguishes the corpus from MCP integrations: MCPs fetch live data, but storing it locally makes it easier to query, build on top of, and cache as concept docs. 1:12:09

Gen 4: Cloud Workspaces and What Comes Next

Alex frames generations as: Gen 1 = feature ledgers, Gen 2 = plan-MD contracts, Gen 3 = the workspace described above. 1:16:02 Gen 4 predictions:

Move off local machine — 300 GB consumed in one month of agent work makes cloud migration urgent. 1:16:36
Shared workspace across a team — a company-global Intel Corpus and ticket system so teammates can see not just what was delivered but how and why. 1:18:28
Agent pools — 10+ cloud agents with independent workspaces all sharing the same roadmap and corpus, running in parallel timelines. 1:16:54
Mobile-first verification — agents send GIFs/screen recordings to the engineer's phone; review becomes a Tinder-style swipe. 1:17:16
"Clone me" skill — distilling the engineer's decision-making style from chat history into an "Alex decision lens" skill so the agent can steer itself without constant human input. 1:28:56

On the question of managed vs. self-built: Alex acknowledges his system is "spit and duct tape" 1:24:56 and recommends most teams either wait for managed agents from Anthropic / OpenAI (currently private beta, slightly more expensive) or use a verticalized provider—while warning that third-party providers typically lag the frontier models on features. 1:23:00