
A managed agent runs without your laptop.
In this part the agent leaves your laptop. You can build the always-on stack yourself from off-the-shelf parts (GitHub, Vercel, Supabase, and an API key) or run it on a managed service. Either way, you move from a clever laptop setup to a digital colleague with an inbox, a schedule, and a brain that survives a restart.
A mill wheel turns day and night. Nobody has to stand beside it.
Tanush Jagdish · Part 5 of 6 · 12 min read
Everything you have built so far lives on your laptop. You open a chat or Claude Code, build a skill, and wire up a brain, and all of it runs only while you are there and your machine is on.
#1Why leave the laptop
What you have
- A capable agent on your machine
- Your skills and memory, local
- Hands on the keyboard, in control
What it still needs
- Approvalsa person signs off on big actions
- Its own addressan email and a phone number
- Audit logsa record of what the agent did
- Shared accessa team can reach the same brain
Claude Cowork and ChatGPT Work now run one person’s scheduled tasks in the cloud (as of September 2026). A managed agent for a team adds these four, and a provider who operates it.
Sooner or later, almost everyone I coach asks the same question, usually unprompted: why am I still typing into a chat window every time? If the agent already has access to everything and already does the work, why am I the one opening the laptop, typing the prompt, waiting, and copying the output somewhere else? One executive in a workshop described the destination well:
“If the AI already has access to everything and is doing everything, why do I not have a dashboard where I have where things are, where progress should be... all in one place. I think this is where the frontier is right now. It’s an unsolved problem.”
an executive in a workshop
Our view is that most people and most companies will end up with an always-on agent, whether they buy it or build it. Picture a chat assistant with its own computer that never switches off, which you can text and which acts for you. This part walks through the whole stack, so you could build it yourself, and explains what a managed service takes off your hands.
A laptop agent is on only when you are. Close the lid, and it is gone. A scheduled task set for 6 a.m. never ran, because your computer was asleep. An email that arrived at 2 p.m. during a meeting sat unread until you opened Claude Code yourself. This wall is about availability, not capability. You have built something that works; now you want it to work without you in the room. For one person’s scheduled work, the agent apps from Anthropic and OpenAI now do this off the shelf: as of September 2026, scheduled tasks in Claude Cowork and ChatGPT Work run in the vendor’s cloud, with no device online. A task that needs files on your laptop still runs only while the laptop is on.
One rule governs this entire part: do not start with an autonomous agent. Earn your way there. We did not start there either. First we made our briefing skill reliable and made sure it understood all the context, and only then did we hand it to an autonomous agent. If you start with an autonomous agent, you cannot tell why it fails. People start ignoring what it does because it is not useful, and once they stop trusting an agent, that trust is hard to win back.
So the order is fixed: a skill that works locally (Part 3), then a brain that holds the context (Part 4), and only then a proven skill that runs on a schedule without you. Every day at 8 a.m., the agent starts on its own computer in the cloud, reads your email and the day’s context, uses your briefing skill to build the PDF, and sends you the morning briefing. An autonomous agent is a trusted skill that runs while you sleep.
#2Gateway versus brain
- 01
Access surface
Access surface
Where a human touches the system. The channel that delivers messages in and replies out.
An early deploymentHQ Slack workspace: all channels, all DMs.
- 02
Routing & control
Routing & control
The traffic cop. Receives events, decides which agent owns the turn, deduplicates, schedules cron work.
An early deploymentSlack app + orchestrator process inside the same pod.
- 03
Runtime compute
Runtime compute
The temporary computer where the agent’s code actually runs. Reads files, executes tools, writes back state.
An early deploymentA single cloud pod, always on, restarted by hand.
- 04
Intelligence
Intelligence
The external model provider. Where reasoning, planning, and language generation happen.
An early deploymentOne strong model as orchestrator, smaller models as sub-agents.
- 05
Durable state
Durable state
What survives a restart. The workspace repo, session history, scheduled jobs, secrets, tool credentials.
An early deploymentA brain repo as a sidecar Git loop on the pod’s disk.
“The agent” is shorthand for five separable layers. Naming them is what lets you swap one (a new channel, a new runtime) without rebuilding the others.
Here is the most important idea in this part. When you text the agent, email it, or mention it in Slack, that channel is just a door; it is not the agent. Your agent lives somewhere else. Whether you reach Oli, our own agent, on Slack or by email, the channel is only the gateway. Behind it sits a Git repository, where the agent’s brain and working repositories live.
Keep the two pieces straight. A gateway is the channel: Slack, email, iMessage, or WhatsApp. It is interchangeable plumbing, and you can add a new door at any time. A brain is the durable part: the repository holding SOUL, AGENTS.md, MEMORY, your skills, and your diary. As I put it on the architecture slides, the brain tells the agent where the body lives; it does not hold the body.
That is why, when I set someone up, the choice of channel is almost an afterthought. I built one client’s agent on email rather than Slack, because a Slack app needs a workspace admin to approve it and email needs no admin. Slack is one way to reach the agent, email is another, and the brain stays the same.
To see the split between door and brain as engineering, break any agent into five physical layers. First, the access surface is where a person touches it: the gateway. Second, routing and control is the traffic cop that receives events, decides which agent owns each turn, removes duplicates, and schedules work. Third, runtime compute is the computer where the agent’s code runs. Fourth, intelligence is the model provider, the API that supplies reasoning and language. Fifth, durable state is what survives a restart: the repository, history, schedules, and secrets. On a laptop, all five collapse into one machine. In a real deployment they separate, and each can fail, restart, and scale on its own. We return to these layers below, when we look at the full system.
#3Meet people where they work
- Route
- Map the sender to their brain; pick the turn’s context.
- Dedup
- Collapse retries and echoes so one message is one turn.
- Heartbeat
- Stay awake; wake the agent on a schedule, not a click.
Agent
private runtime
Model
intelligence
The channel is a door, not the agent. One gateway turns five front doors into one Oli, so you meet people where they already work and still run a single brain behind it.
When I deploy an agent for someone, I do not guess the channel. I ask where they spend their working day. If they work mostly in email and text messages, the agent gets its own phone number and inbox, and those become the way in.
Getting from Claude Code on your laptop to an agent with an inbox is a staircase, and the first step is a Gmail skill. Away from your desk, send yourself an email from your phone, and watch Claude Code on your computer pick it up, process it locally, and reply. Once that loop is clear, moving it from your computer to a data center is a natural next step. A phone number is one more step on the same staircase: instead of an email skill, the agent has a webhook connected to a phone-number service. That webhook, which turns a text message into an agent turn, is where services such as Sendblue, or OpenClaw’s iMessage channel, plug in. Only the door changes; the idea stays the same.
One design constraint matters more than it looks: be careful about whom the agent may answer. You do not want someone to text you and get a reply from the agent through your number without your knowing what it said. People then lose trust in who they are texting: is it you, or an AI agent? Use your phone as a control channel to your own agent, not for automatic replies to other people. If the agent has its own inbox instead of borrowing yours, it behaves like a real colleague. That inbox can be a Google Workspace account, so the agent can create Google Docs and share them with you, just as an employee would.
#4Build it yourself
where the agent’s code and brain live
runs the agent on request or on a schedule
the database it reads and writes
the model that does the thinking
GitHub is the cloud, Vercel is the raw power, Supabase is the memory.The names are scarier than the things.
Suppose you want to build this rather than buy it. Here is the whole stack; the names sound more intimidating than the things are. GitHub holds the brain, Vercel provides the compute, and Supabase provides the memory.
- GitHub: a private repository with version control. Your brain lives here, with every version of every file saved.
- Vercel: compute. It is rented computing power without the setup work of running servers on AWS or Google Cloud yourself.
- Supabase: the database, with a free tier. A database is rows and columns, much like a spreadsheet, that you work with through code; Postgres and SQL are the standard tools. If you would rather skip Supabase, a Google Sheet can serve as the database.
Why GitHub, and not just your hard drive? This is what makes deployment click. When the agent ran on your laptop, your computer was on and the agent read files locally. To run without your computer, the model still needs a file system somewhere, and the GitHub repository provides it: it becomes the environment in which the agent wakes up, reads its instructions, connects to its tools, and saves its output. Your agent wakes up inside the repository, and that is its world. One discipline to internalize: a site on Vercel updates only when changes are pushed to GitHub, because Vercel is connected to GitHub, not to your computer. Local changes are invisible to the deployed agent until you push them. Do not overthink the front end, either; building the website is the easiest part. A website takes input, transforms it, and returns output, so define those three things clearly.
Moving from laptop to cloud changes your billing, and it catches people out. On your computer, your subscription pays for the AI; in a cloud stack you build yourself, you need an API key. Your Claude subscription covers your own work in Anthropic’s apps; as of September 2026, that includes the scheduled tasks those apps run in Anthropic’s cloud. An always-on cloud agent that you host yourself runs on a metered API key, so set a usage cap (I suggest starting at $10) so a runaway loop cannot surprise you. Do not try to run that agent on a consumer subscription: subscriptions are priced for interactive use, and providers restrict using them to power other tools. Metered costs are real. One of us had an AI build a unified ledger end to end overnight and ran up an $800 bill. If the work succeeds, the cost can be worth it, but watch the meter.
#5Connectors and the always-on loop
- 01
Email in
A partner forwards a deck. The agent reads the email and its attachments.
- 02
Brain
Writes a structured summary: company, stage, thesis fit.
- 03
WhatsApp out
Drops the summary on the surface the partner reads first.
- 04
CRM
Creates the record. The work persists where the team works.
Email in, WhatsApp out, CRM written, and at no point was the channel the agent. The channels were doors; the work was one brain doing one job.
A deployed agent is only as useful as what it is connected to; connectors are the difference between a clever toy and something that runs part of your operation. Connecting to Gmail takes one sentence of work, because Gmail has a well-documented API: ask Claude Code to connect you to the Gmail API, and it walks you through the setup. Then you can say “look through my emails; what do you think?” The first workflow most people build is email drafting: “Look at my Granola notes and my last exchange with this person, and draft a reply.” Across our deployments, it is one of the most-used workflows.
Email to CRM, though, is the connector that best shows off the architecture. A deal email arrives. Your agent reads the body and the attached deck, posts a clean summary to a chat channel (company, stage, thesis fit), and creates the record in the CRM. A demo I run often: forward the agent a partner’s reply and say “add this to our CRM, update our diary, and advise me on the follow-up.” It does all three and comes back with grounded advice. That is the mental shift: the value is in workflows, not integrations. An integration means the agent can touch the CRM. A workflow means a deal email becomes a record, an alert, and a filed document every time, without you. Integrations are the parts; the workflow is the product.
Here is where always-on comes from. There are two ways to work with a Claude Code agent: chat and scheduled tasks (“every day at 6 a.m., do these things”). On your laptop, Claude Code’s /loop command can repeat a prompt on an interval, but a laptop loop dies when the lid closes. Anything that must run reliably at the same time every day has to live on a server, whether that is the vendor’s cloud or one you set up yourself. Think of autonomy as a dial. At the basic end, the agent sends you a daily digest. At the advanced end, it is always on, with a heartbeat that wakes it at short intervals to consider what it can do for its principal right now. In between, it checks email every few minutes and adds anything new, summarized, to its running context; it also notices when a meeting ends, pulls the Granola notes, summarizes them, and adds them to the stream. That cadence is what makes a deployed agent feel real-time rather than batch.
This is also where the rule about graduating trusted skills pays off. A demo I run chains two skills with a single instruction: “Use the newsletter skill and the Gmail skill to send me an email every morning.” It works once, you watch it, and you trust it. Putting that prompt on a daily schedule on a server is the next step.
#6The managed architecture and the dashboard
Now zoom out to the whole system. When I draw the architecture, I separate it into five columns, and I expect most people building personal agents to arrive at something similar. Keep your data sources and front doors, where the work happens, separate from an ingestion layer, which feeds a storage layer that agents read from. Sending agents back to raw sources again and again is messy: they get confused and may not look everywhere. On top of storage, agents produce briefs and dashboards, and then comes the output.
You cannot just point an agent at your raw email and Slack and call it done, because agents cut corners: today they rarely search everything, and after covering most of your email and part of Slack, they tend to stop. So you build a storage layer for the agent to read, fed by an ingestion layer that does the looking. Ingestion can be deterministic code (bank or health data piped straight in) or AI collectors for messy, unstructured material. This is the five-layer breakdown from earlier, built out properly. Instead of one machine doing all five jobs, a dispatcher routes, deduplicates, and schedules work across isolated agent runtimes that can fail and restart independently, while durable state (the repository, sessions, schedules, and secrets) lives outside any single runtime, so no crash can take it down. That is multiplexing: one dispatcher serving many agents. It is also the on-ramp to Part 6: per-person brains, when you are ready, on top of a shared firm brain.
A dashboard is where you read state instead of re-prompting for it. A managed agent does work on your behalf, lives in your communication channels, and has a dashboard. There are three surfaces: chat, the conversational door (Slack, email, text), where you ask; the dashboard, where the agent shows you where things stand without being asked; and the monitor, which shows what the agent did while you were not looking, the work that happens before anyone opens Slack.
Behind the dashboard is a process we call dreaming, which is how the agent decides what belongs on it. Dreaming is a set of background agents you never talk to that review everything that has happened and, guided by your feedback, separate signal from noise. It runs several times a day, overnight when nobody is working, and after important events, such as the end of a meeting or the arrival of a key email. It has two halves. One is a live context stream: signal, continuously extracted from raw events, which the dashboard renders. The other turns that stream into a narrative daily brief: you have four meetings coming up, and here are the three things that matter. Sleep is the analogy. When you sleep, your brain consolidates the day’s experiences into your understanding of the world, and the agent does the same on a schedule.
One lesson sits under all of this, and it is why the dashboard is not just another chat window: do the analysis once, store it in a central context layer, and have everything read from it. If you, the dashboard, and a teammate each want to know about tomorrow’s meeting, that should not mean three separate analyses. Analyze the world once into a single shared source of truth, and let the dashboard, the daily brief, and every person read the same synthesized state. We run this on ourselves every morning. Our internal agent posts a brief in Slack without being asked: the day’s external calls, the RSVP count for an upcoming event, and the background for each meeting. It dreamed overnight and posted.
#7Build it, or run it managed
You have a real choice, and both paths are legitimate; that is why this part teaches the whole stack. You can build it yourself: GitHub for the brain, Vercel for compute, Supabase or a Google Sheet for the database, an API key for the intelligence, a webhook for the phone, the Gmail API for email, and a scheduler on a server. You now know every piece. What remains is upkeep: maintaining memory, keeping connectors working, watching costs, and adopting new models as they arrive. Or you can use a managed service that runs the same architecture for you, with the dashboard, dreaming, and the central context layer already built. For one person’s routine work, scheduled tasks in a vendor app may be enough. A managed agent for a team has its own identity and inbox, memory that the team shares and governs, a person’s approval before consequential actions, audit logs, and a provider who operates it. Olito’s own managed agent, Agent Oli, an executive chief of staff, is available by invitation; olitolabs.com/products has details.
Either way, you have crossed the line that matters. You no longer have a clever laptop setup; you have a digital colleague with an inbox, a phone number, a schedule, and a brain that survives a restart. In one learner’s words, this is where it is all headed:
“Ultimately I’d like to create a mini Oli for myself. Or multiple mini Olis. Which can do a whole host of things.”
a learner
That raises the question Part 6 starts with. Should each person have an agent with its own computer, or should the whole team share one agent as its chief of staff? Nobody has settled the answer; teams are experimenting, and a standard may emerge.
The research behind this part.
Continue with the next part.
Want to go faster on your real work?
Coaching is the same method with someone beside you. It is by referral or invitation, and we are at capacity. We write back as capacity opens.