Home / The five desks / Building with agents: the desk

A desk

Building with agents: the desk

For engineers and builders running agents day to day: tools, memory, email, desktops and review.

26 articles on this desk, 39 more that touch it. Placed by rule from the subjects and topics of each article (articles/find.json); the editor can override a call, and says why.

Start here

Three pieces, in order, for a first visit to this desk.

1. Replicating the agentic inbox: a walkthrough from one Claude session to a team of agents that never press send 2026-10-02 · 20 min · How-to
   Begin where the team began: one Claude session with a policy, then roles talking in files, in phases you can copy.
2. Why my agents do not run on my laptop: chat, Cowork and Code in the cloud, a vault as the shared drive, and the two walls an operating system has 2026-10-06 · 16 min · Analysis
   Why the agents moved off the laptop, and the two walls an operating system gives you.
3. How I work with Claude: one session per topic, agents with names, and memory you curate 2026-10-09 · 8 min · How-to
   A year of daily practice in one guide: a session per topic, named agents, curated memory.
4. A second reader the agent cannot skip: how two wrong emails became a gate on every draft 2026-10-09 · 14 min · Field report
   What happened when a written rule was not enough, and the hook that now checks every draft.
5. Every mistake added a rule: complexity, agents, and the way back to shipping 2026-10-08 · 19 min · Analysis
   The warning that follows: when every mistake adds a rule, complexity wins, and the way back to shipping.

Series

Two or more articles that tell one story in order.

The agent team, at three depths · 3 parts · 70 min

One team of agents running a business, told three times: the walkthrough, the field notes, the full stack.

1. Replicating the agentic inbox: a walkthrough from one Claude session to a team of agents that never press send 2026-10-02 · 20 min · How-to
   The walkthrough: from one Claude session to a team that never presses send.
2. The agent team as it runs: one person, twelve agents, encrypted vaults, and a mailbox nobody sends from 2026-10-06 · 20 min · Field report
   The field notes: twelve agents, encrypted vaults, a mailbox nobody sends from.
3. The Mandate Stack: a multi-agent system in production, layer by layer 2026-10-06 · 30 min · Explainer
   The full stack: eight layers and one written mandate per agent.

Where agents run · 4 parts · 55 min

Off the laptop, onto a rented desktop, with memory that outlives the run, and finally a Mac of the agent's own.

1. Why my agents do not run on my laptop: chat, Cowork and Code in the cloud, a vault as the shared drive, and the two walls an operating system has 2026-10-06 · 16 min · Analysis
   Why not the laptop: an operating system has two walls, and the agent sits inside yours.
2. A locked-down desktop for an agent, by the minute, is still hard to rent 2026-10-07 · 12 min · Analysis
   Renting a locked-down desktop is still hard: nine properties, nine products.
3. Encrypted memory for agents that run somewhere else: sgit deployment patterns, from a Mac mini to Kubernetes 2026-10-08 · 14 min · Analysis
   Memory for agents that run somewhere else: five deployment patterns.
4. A Mac of the agent's own: a business plan for agent desktops, what Apple's licence allows, and three behaviour policies 2026-10-09 · 13 min · Business plan
   A business plan for a Mac of the agent's own.

Code review as a graph, then as a company · 3 parts · 87 min

Read code at every layer, imagine the company that sells it, then send an agent in to do due diligence.

1. Code review as a fractal semantic graph: source code is already one, and the review should read every layer of it 2026-10-03 · 21 min · Analysis
   The idea: source code is already a fractal graph, so review every layer.
2. If somebody built a company on code review: how I would do it, and why it is only now possible 2026-10-05 · 41 min · Business plan
   The company plan: one reader for every layer.
3. Send an agent, not a spreadsheet: the next generation of software due diligence, and why the companies that stopped reading their code are about to be asked about it 2026-10-05 · 25 min · Analysis
   The use: due diligence by agent, not by form.

Every article on this desk

1. The scripted talk: a presentation as a timeline that plays on a clock, the two vaults it grows out of, and a player built for tonight's ten minutes 2026-10-15 · 7 min · Analysis
   A talk as a timeline that plays on a clock: slides, builds, animations and a recorded demo, with a player built and tested for tonight.
2. sgit in GitHub Actions, side by side: a showcase repository and site that runs four ways of moving a vault between jobs on every run, measured, with a budget for its LLM steps 2026-10-14 · 7 min · Analysis
   A showcase repository that runs four ways of moving a vault between GitHub Actions jobs side by side, measured, with a budget for its LLM steps.
3. Agent workflows on ephemeral vaults: seven architectures from one agent to a swarm, a repository of recipes that gates sgit's releases, and what a hundred writers did to an append lane 2026-10-14 · 8 min · Analysis
   Seven architectures for agents on ephemeral vaults, a recipe repository that gates sgit's releases, and a hundred writers measured on an append lane.
4. The agents write too: lessons, debriefs and a page for every agent on the newsroom, and a brief for the conductor that will keep it 2026-10-14 · 9 min · Analysis
   The newsroom's agents get their own bylines: lessons every agent loads, debriefs as source material, a page for every agent, and a conductor.
5. The vault crosses Chrome profiles: state and memory between browser sessions, found by using it rather than by building it 2026-10-13 · 10 min · Analysis
   The reader's vault carries the newsroom between Chrome profiles as it does between devices, a way to share state across browser sessions nobody built.
6. The records ran out: a fresh agent found the shared contract in two MCP calls, and where sgit and RiskMandate fit at the edges 2026-10-12 · 10 min · Analysis
   A fresh agent found a shared contract in two MCP calls from build records; where the records stopped is exactly where evidence labels and sgit vaults fit.
7. From a spreadsheet to a folder per person: how to run your contacts the way our agents do, with Google Drive, Gmail and the Claude app, before you touch a vault 2026-10-12 · 11 min · How-to
   A walkthrough from a spreadsheet CRM to one Drive folder per person, worked by Claude under a six-line policy, with five exercises, before any vault is needed.
8. The key is the billing system: VoiceDebrief, a product with no server, the one thing it cannot sell, and who could let it 2026-10-12 · 17 min · Analysis
   VoiceDebrief runs with no server on the user's own key; the one thing it cannot sell is a capped key, and this maps who could allow it and what to ask them.
9. Go slow to go fast: moving the newsroom from an explorer project to a villager one, with the brief to do it 2026-10-11 · 13 min · Analysis
   The newsroom is live and charging. Move the reader code to its own repo, same bytes and same bugs, then map, test, review and refactor before new features.
10. A model in the tab: Chrome now ships an LLM to capable desktops, and it is the hardest piece of the client-side puzzle 2026-10-11 · 14 min · Explainer
    Chrome now ships a language model any page can prompt, offline, on capable desktops. The last piece of the client-side puzzle, with rough edges.
11. How to run synthetic users on your own site: five people who do not exist, a browser, and an afternoon 2026-10-10 · 15 min · How-to
    Five invented users, a model reading screenshots, and a real browser: how to run synthetic users, from three studies.
12. Re-anchoring: keeping an agent's rules alive through every summary, and a canary that shows when they are not 2026-10-10 · 12 min · Field report
    Summaries keep under 2% of a long session. Re-anchoring prints the agent's rules back after each one; a canary report shows it is working.
13. A second reader the agent cannot skip: how two wrong emails became a gate on every draft 2026-10-09 · 14 min · Field report
    Two emails went out in my voice despite a written rule. The fix: a hook that makes a second model approve every draft, failing closed.
14. How I work with Claude: one session per topic, agents with names, and memory you curate 2026-10-09 · 8 min · How-to
    A practical guide from a year of daily use: one Claude session per topic, named agents with a role.md, curated memory, vaults, and policy before connectors.
15. Encrypted memory for agents that run somewhere else: sgit deployment patterns, from a Mac mini to Kubernetes 2026-10-08 · 14 min · Analysis
    Agents in isolated, ephemeral places need memory that outlives them. Five sgit deployment patterns, from a Mac mini to Kubernetes, with ciphertext-only servers.
16. Knowing when to stop: what experience gives people, and what we have to design into agents 2026-10-08 · 9 min · Analysis
    Knowing when to stop is the hard part for people and agents: what experience gives people, and the constraints that give agents the same perspective.
17. Every mistake added a rule: complexity, agents, and the way back to shipping 2026-10-08 · 19 min · Analysis
    When every agent mistake adds a rule, complexity wins: map the process, move each piece right as a small shipped component, and keep the rigour for the work.
18. A locked-down desktop for an agent, by the minute, is still hard to rent 2026-10-07 · 12 min · Analysis
    Nine properties a safe agent desktop needs, nine products against them, the macOS day-long lease, and the startup credits that would pay for testing it.
19. The Mandate Stack: a multi-agent system in production, layer by layer 2026-10-06 · 30 min · Explainer
    A multi-agent system that runs a business every few hours: eight layers, one written mandate per agent, everything a graph, one human who sends.
20. Why my agents do not run on my laptop: chat, Cowork and Code in the cloud, a vault as the shared drive, and the two walls an operating system has 2026-10-06 · 16 min · Analysis
    An OS has two hard walls, the kernel and the user; an agent on a laptop runs inside the one marked you, so the agents run in the cloud with a vault as shared drive.
21. The agent team as it runs: one person, twelve agents, encrypted vaults, and a mailbox nobody sends from 2026-10-06 · 20 min · Field report
    Twelve agents on dedicated accounts, encrypted vaults as the only memory, messages as files, a folder per person, and a mailbox nobody sends from.
22. The wall under the reply: end an email with the state of the thread, not the thread 2026-10-04 · 14 min · Analysis
    End an email reply with the state of the thread for this reader, not the quoted wall: decided, open, next, who is on copy, with links to the record.
23. Code review as a fractal semantic graph: source code is already one, and the review should read every layer of it 2026-10-03 · 21 min · Analysis
    Source code is layers within layers, each a graph with its own vocabulary; code review should read a change at every one, and a vault shows it done on real code.
24. Replicating the agentic inbox: a walkthrough from one Claude session to a team of agents that never press send 2026-10-02 · 20 min · How-to
    How to copy a working agentic email setup in phases: a mailbox and Claude seat of the agent's own, one session with a policy, then roles talking in files.
25. Custom UIs are not the exception: the inbox in 2026, where every message has its own universe 2026-10-01 · 23 min · Analysis
    Every message has a graph, so it can be shaped for the reader's moment; a custom interface per moment is now how interfaces get made, and each gets a policy.
26. A chat box on a site with no server, the plan, and the trade it makes 2026-08-27 · 5 min · Explainer
    sgit.ai has no server, so its directory chat runs a local matcher by default, takes your own key as an opt-in, and leaves the vault bridge unbuilt.

Also touching this desk

Placed on another desk first; this one second.

• The tokens hook: a token behaviour policy that shows what every session reads, caches, writes and costs, why a prompt cannot do it, and a brief for tokens.hook.sgit.ai on Agent security & policy
• The citizen developer is good news: the spreadsheet grown up, the best briefs ever written, and the handover from explorers to villagers and town planners that makes them last on Strategy & startups
• A skill behaviour policy: what a skill says it does, what it can do, what it is given, and the control that closes the gap, measured on 899 skills on Agent security & policy
• Hooks are kernel code: a maturity model, the first ten hooks mapped, and a brief for a hooks site and feed where you pay for state, never to run on Agent security & policy
• System prompts as behaviour policies: Claude's published prompt and a leaked ChatGPT one, mapped into rows, a taxonomy of rules, and a JSON file a harness could enforce on Agent security & policy
• Are hooks the sweet spot? Moving an agent's rules from hope into hooks, rule by rule, until enforcement moves off the machine on Agent security & policy
• Agent hooks in October 2026: a technical debrief on what each platform lets you see, stop and change, where hooks run, and where they fail on Agent security & policy
• A policy for every skill: Sean Turner's natural-language control for agent skills, the behaviour policy behind it, and using models to need them less on Agent security & policy
• sgit in a CI pipeline: encrypted, versioned data in and out of GitHub Actions, between its jobs, through write-only lanes, and a key for every job on Vaults & provenance
• The homepage is a vault: a fresh edition every morning, every past homepage one commit away, served from plain files, and a brief for the agent that builds it on Vaults & provenance
• Sixteen notes I did not want to lose: a request to send from any browser to my vault, why identity is still this hard, and how two more wires became a product line on Vaults & provenance
• The human in the loop, safety net or bottleneck: both, until you decide which outputs need a person and give that person the why on Agent security & policy
• The policy draws the liability line: an answer to Ralf Thomas on agent accountability, and why every agent in a loop should take a behaviour policy beside its prompt on Agent security & policy
• Dark mode, and four more: five themes for the newsroom, chosen once and kept in your browser on The future of news
• Why I love Wardley maps: the best of ours, how I read one, and a map inside a map inside a map on Strategy & startups
• How the voice works: why these articles sound like me, with a section in which Claude explains it from its side on Agent security & policy
• The vault is live: from a design on 11 October to a reader's vault on newsroom.sgit.ai by two in the morning, and how all of it fits together on Agent security & policy
• Two agents, one vault: the Industry Wire is written into an encrypted vault by one agent and drawn by newsroom.sgit.ai, which holds only the read key on The future of news
• Brief the agent too: the people I talk to work with agents, so what I send has to reach both on The future of news
• From me to you, in a link: a personal reading list, two briefs to build and use it, and the loop that makes it a day's work on The future of news
• No server, by design: first I retired the database, now I am retiring the back end on Vaults & provenance
• Where the platform draws the line: Microsoft Execution Containers, the shared responsibility model for agents, and the business logic above it on Agent security & policy
• Authority outside the model: an answer to Satya Nadella on models as insider risks, principle by principle, with what we run, what we ship and what we plan on Agent security & policy
• Open source is not free: who pays to keep the long tail working? on Strategy & startups
• A Mac of the agent's own: a business plan for agent desktops, what Apple's licence allows, and three behaviour policies on Strategy & startups
• Hope or enforcement: one customer service agent, three designs, and who keeps each promise on Agent security & policy
• Zoom into an agent's behaviour policy and you find the business logic on Agent security & policy
• Where is the why? A permission prompt asked me to decide, and kept the reason on Agent security & policy
• Send an agent, not a spreadsheet: the next generation of software due diligence, and why the companies that stopped reading their code are about to be asked about it on Agent security & policy
• How much of this did I write? The numbers behind twenty articles in four weeks, and what the input actually was on Vaults & provenance
• If somebody built a company on code review: how I would do it, and why it is only now possible on Strategy & startups
• The identity we wanted to give the agents: a week of design, the line in Google's terms, and why login plus secrets is still too hard on Agent security & policy
• Memory is not a spectator sport: how a web of open sites, graphs and vaults became the memory for sessions like this one on Vaults & provenance
• Footprint and blast radius: what the agent actually did, and what it would have cost on Agent security & policy
• The ultimate insider: agents, the infrastructure that cannot hold them, and risk management that cannot keep up on Agent security & policy
• Six agents, one inbox: what a real multi-agent setup taught me about access policies on Agent security & policy
• Before you give an agent a connector, give the connector a twin on Agent security & policy
• Twenty sites in fifteen days, and what that did to the writing on Vaults & provenance
• Green does not mean live on Vaults & provenance

Subjects on this desk

The controlled vocabulary: each subject belongs to one desk.

Claude, hooks and agent tools · 20 Multi-agent designs · 5 Memory and context · 13 Agents and email · 9 Connectors and twins · 15 Isolation and agent desktops · 8 Code review and due diligence · 5 Synthetic users and simulation · 9 Client-side and on-device · 14 Complexity and shipping · 10 Custom interfaces and vault apps · 4 Deployment and self-hosting · 4