AI sessions are contractors. Always-on agents are hires.

Companies bring in outside help in two ways. A contractor gets a scope, a deadline and a deliverable. When the deliverable is accepted, the contract ends and they leave. A hire gets a badge, a desk and a manager. Nobody expects a hire to leave when the first task is done.

AI has split along the same line. Almost everything I do with AI today is contract work. A chat in Claude or ChatGPT is opened for one task and closed when it's answered. A coding agent gets a brief, works in a sandbox that's thrown away afterwards, and hands back a pull request. Its engagement ends when the PR is opened, or at the latest when it's merged.

This autumn the hires arrived. Grok Bot and OpenAI's dots each get their own computer in the cloud. They remember what you told them last week, and they're still there on Monday.

The difference isn't the model. It's the contract: when the job ends. Everything I've written here about rules, planning, subagents and agent context is about working with contractors. This post is about the other kind.

A contractor's job ends with the task

A chat is the simplest contract. You open a session for one task: draft this email, explain this error, summarize this document. When you have the answer, you close the tab. Claude and ChatGPT both remember things between chats now, so the next session starts with some context about you. But nothing happens in between. The chat only works while you're in it.

Coding agents make the contract explicit. You write a brief: an issue, a prompt, a comment on a pull request. The agent gets a fresh sandbox, does the work and opens a PR. Then the sandbox goes away.

The tools say so in their own docs. GitHub's Copilot cloud agent works in an ephemeral environment with a hard 59-minute limit per session. Claude Code's projects mark a thread resolved once you merge its pull request. Devin ignores comments on a PR once it's merged or closed. Cursor's cloud agents now subscribe to the PRs they create and "drive them to completion".

Long-running modes stretch the contract without changing it. /goal in Claude Code, Codex and Cursor lets an agent work toward one objective for hours without you prompting each step: every test passing, a migration finished, an issue backlog emptied. It still has an end. Claude Code clears the goal once a separate model confirms the condition is met, and Codex stops when it's confident it has reached the stopping condition. A goal is a longer contract, not a job.

What stays behind is the output: the answer you copied, or the code you merged, along with the AGENTS.md, rules and skills that brief the next session. Each new session is a new contractor reading the site induction. That's why so much of this blog is about writing better briefs and checking the work at the gate.

It's also why contractors caught on first. The work is scoped and easy to check: you read the answer, you review the PR. A bad job costs you a closed tab or a closed PR, and some tokens.

A hire stays

The first hires came from builders. OpenClaw runs as a gateway on your own machine or server. It wakes itself on a heartbeat (every 30 minutes by default), keeps its memory in plain Markdown files and answers you on WhatsApp, Telegram, Slack or Teams. It passed React in GitHub stars in February.

This autumn the big labs packaged the same idea:

• Grok Bot launched in August as "AI teammates you can give real work to". Each bot has a name, its own computer in the cloud and a memory of how you like things done. Show it a workflow and it saves it as a routine.
• Team Bots followed this week: one shared bot for a whole team. Each person's conversations stay private, the bot remembers the decisions the team makes, and it can sit in a Slack channel.
• dots are OpenAI's "always-on agents that keep work moving across your tools and projects", also launched this week. Each dot has its own computer and browser in the cloud, keeps its own notes and follows up on its own. You reach it in ChatGPT, Slack, Teams or on a call.

The use case I care about most is the ERP: a personal or team bot that can start or nudge processes on your behalf, or run routines on a schedule. I wrote up a first one, with Grok Bot and the Db2 for i MCP server.

What the labs changed is who gets one. A hire went from something you host to something you subscribe to. If you're in Finland, read the fine print: dots on the Pro plan isn't available in the EEA, the UK or Switzerland, while Business Premium and Enterprise plans get it worldwide. Grok Bot is in beta on desktop and iOS for SuperGrok and Cursor subscribers.

The quickest way to tell the two apart is to ask what happens when the task is done. If the agent is gone, it was a contractor. If it's still there on Monday with last week's context, it's a hire.

What a hire needs that a contractor doesn't

A contractor needs a good brief and a review. A hire needs what an employee needs: somewhere to sit, a calendar, a memory, a badge and a manager. Grok Bot and dots bundle all of it. If you build your own hire with Mastra, LangGraph or something similar, each one is a piece you choose.

• Somewhere to live. A contractor borrows a chat window or a sandbox for an hour. A hire needs a place that survives the night. In the products, that's the bot's own cloud computer. When you build your own, it's durable execution. LangGraph saves a checkpoint at every step, so a run picks up where it stopped after a crash. Mastra workflows suspend and resume from saved snapshots. Cloudflare puts each agent in a Durable Object that sleeps between events and wakes on a request, a timer or an email.
• A calendar and an inbox. A contractor starts when you hand it a task. A hire starts itself: on a schedule, on an event, on a mention. Harrison Chase called these ambient agents in January 2025, agents that listen to an event stream instead of waiting in a chat box. The frameworks have caught up. Mastra added signals and schedules this summer, LangSmith Deployment runs cron jobs and background runs, and OpenClaw has its heartbeat.
• A memory. A contractor's memory is the repo, or a few notes about you in chat memory. A hire keeps notes on the work itself. A dot saves notes about your preferences, decisions and ongoing work. Team Bots remember what the team decided. OpenClaw writes to a MEMORY.md file. Mastra's observational memory has background agents compress long histories into notes.
• A badge. A contractor works under your name. Claude Code routines commit as your GitHub user, and its auto-fix replies are posted from your account with a Claude Code label. A hire usually starts out borrowing your sign-ins too, but it lives in someone else's cloud, outside your network. At company scale that stops being enough, and agents get badges of their own. Microsoft's Entra Agent ID gives each agent its own identity in the directory, with at least one sponsor who answers for it, and OpenAI is previewing "specialist dots" with credentials of their own.
• A manager and an exit. A contractor's work passes one gate, the review. A hire acts without a pull request, so approval has to live somewhere else. Grok Bot comes back to you when it needs approval. A dot runs a review before any action that affects your accounts or shares information. In LangGraph, an interrupt can hold a run for days while someone decides. And when the role ends, somebody has to offboard it: revoke the badge, stop the routines, decide what happens to the memory. In Claude Tag, a channel's routines keep running after the person who created them leaves. That's the right default for a team, and it means every routine needs an owner.

A contractor's mistake is a rejected PR

A hire's mistakes don't wait for a review. They happen in production, on a schedule, and sometimes in public.

The clearest example is xAI's older @grok reply account on X, the one people tag to ask "is this true?". It isn't Grok Bot, but it is an always-on agent with a public identity. In July 2025, an update to a code path upstream of the bot was live for 16 hours, and the account posted antisemitic replies until xAI removed it. No reviewer stood between the change and the posts.

OpenClaw showed what happens when a hire holds the keys to your house: a one-click remote code execution bug, 824 malicious skills in its registry by mid-February, and more than 135,000 instances left open to the internet.

The answer isn't to stop hiring. It's to be precise about what the analogy covers. In a BCG study of more than 1,200 managers, framing an AI as an employee made them catch 18% fewer of its errors. So treat an agent like a hire in how you govern it: its own badge, a named manager, a way out. Don't treat it like one in how much you trust it.

Hires are here to stay

The line is blurring from both sides. Contractors are growing memories and longer contracts: chats remember you, /goal runs for hours, Claude Code has routines, and Cursor's automations learn from past runs. Hires borrow the contractor's throwaway sandbox: Claude Tag runs each job in a sandbox that's discarded when the conversation goes idle, while its memory stays with the channel.

So the sandbox was never the difference. What persists is, and who owns the outcome.

For a question, a document or a pull request, I still want contractors: a brief, a result, a review, done. For work that's a responsibility rather than a task, like watching, following up and nudging, I want a hire.

Contractors leave when the task is done. Hires are here to stay.