OpenAI shipped one dot. Meet your octos: a crew of AI agents on any model

On September 29, OpenAI launched Dots: an always-on AI agent in ChatGPT with its own cloud computer and browser, a name you give it, and work that carries on after you close the tab. You don't chat with it. You hand it the work.

We read the launch twice, because we've been building exactly that for months. Octomind Cloud already gave every agent its own cloud computer, ran routines that repeat a job every morning, answered in Telegram, WhatsApp and Slack, and kept memory between conversations. Every part was there.

What Dots had and we didn't was the noun. OpenAI gives people one thing to name and own. We were giving them three — a machine, a session and an agent role — and leaving them to assemble an agent out of the parts. Each question made sense on its own. Together they made you an operator of infrastructure before you'd typed a word of the job.

So we fixed the noun. As of today, Octomind Cloud is built around one: the octo. An octo is an AI agent for one thing you're working on — the blog, a client, your money. You name it, it keeps its own folder, memory, conversations and routines, and you hand it jobs. Not one of them: a whole crew, on any model you like, with everything the cloud already did still underneath.

One dot, or a crew

Dots and octos share an idea. They differ on where it goes next.

Dots details are from OpenAI's announcement and launch coverage, September 29–30, 2026.

Three of those rows are the whole argument.

A crew beats one assistant. One agent that handles everything keeps one pile of memory and guesses at its context. An octo only ever sees one workstream, so it knows what it's for by construction. And a crew is cheap: octos share a machine, five to a Small, so six of them cost one computer, not six.

Any model, not one vendor's. The best model for drafting a launch post isn't the best one for checking forty pricing pages at 3 a.m. Each octo can run on its own model, you can switch in the middle of a conversation, and you pay what the provider charges plus 5% from one balance. No lab gets to decide which brain your work runs on.

Your hands on the machine. An agent with its own computer is half the story if you can't get into the computer. You can get into this one.

Here's what we cut to get there, and the handful of decisions that fell out of it.

Three nouns was two too many

The old panel wasn't wrong — it was honest about how the system works. A machine is a real container. A session is a real conversation with its own transcript. An agent role is a real prompt with its own tools. We showed you all three because all three exist.

But the order people meet things in matters more than whether they're true. When the first screen asks "which machine?", the product is telling you its unit of work is a computer, and it invites you to think like the person who runs one: a machine per task, conversations titled "New session", a list of agent roles to choose from before you've said a word. The questions we asked up front were our questions, not yours.

What people actually bring is a workstream. "Keep an eye on competitors." "Write the blog." "Sort out invoices." A workstream outlives any single conversation, needs somewhere to keep its files, and repeats. That's the shape of an octo.

One noun: an octo

Everything the panel shows is now about octos:

• The home screen is one line to type a job into, the crew as tiles, and what they did lately.
• The sidebar lists your octos, not your machines.
• An octo's page is the conversation on the left and everything about the octo on the right.

Each tile carries exactly four facts: the octo's name and state, what it's doing or last did, when it next acts on its own, and what it cost this month. Nothing else earns a line. If a fact isn't one of those four, it lives on the octo's page.

What we removed

A rebuild like this is mostly deletion. Gone from the main path:

• The Overview page. Its numbers now live where they're used: each octo's spend this month is on its tile, and your usage sits in the sidebar foot, always visible and never in the way.
• The Sessions page. A flat list of conversations across every machine had no owner. Conversations now belong to an octo, and each octo's header has its own picker and ＋ New conversation.
• The agent picker. Choosing a role before you've said what you want is no longer your problem — more on that below.
• Machines as a first step. Your first job creates your first octo, and the octo finds itself a machine.

None of it is hidden. Machines, terminals, workflows, the config editor and the model routing table all sit behind Advanced at the bottom of the sidebar, exactly as capable as before. Advanced is where the machinery lives; the default path is for people with a job.

The right specialist, automatically

You never pick an agent. Every octo runs as the cloud's orchestrator: it reads the job, and when a specialist fits better — a writer, a researcher, a developer, all drawn from the same open registry the CLI uses — it hands the work over. The specialist works in the octo's own folder, and its result comes back into the same conversation.

You still see who did the work. Each reply carries a byline: in the screenshot above, Competitors · via content:article means the Competitors octo passed the comparison to the article-writing specialist, which wrote trackers.md and reported back. The decision is automatic; the record of it is one glance away.

The home screen fits on one screen

We gave the landing view a hard constraint: on a laptop, with a few octos, you should see everything without scrolling. That forced real choices.

• The headline stays; the paragraph under it went. The first-run wizard and the setup checklist teach what an octo is. On every later visit, a paragraph is just distance between you and the place you type.
• Octos became two-line tiles. Big cards looked friendly with two octos and absurd with six. A slim tile keeps the same four facts and lets three sit in a row.
• "Lately" shows three rows. "Show more" opens up to twenty in place. The full history of any octo is on its own page, where it has context.
• "＋ New octo" moved into the section heading, so it costs no row at all.

The same pressure reached the octo page. Its "Did" list shows the last four things and folds the rest behind Show more, so a month of routine runs doesn't push its files off screen.

The mark is a status light, not a mascot

OpenAI gave its dots a bubbly cartoon persona. We went the other way. Every octo has a mark: the Octomind pixel octopus in its own colour, with no face to perform feelings. The motion is the state:

• Tentacles moving — it's working on something right now.
• Eyes looking around — awake, waiting for the next job.
• Dimmed — asleep. Its machine is suspended and costs only storage; your next message wakes it.
• Standing still inside a red ring — paused, because the account hit its usage limit.

States are derived, never stored. There's no status column that can drift out of date; the cloud works an octo's state out from two things — its conversation's own history, and whether its machine is up.

Two rules kept the marks honest. First, colour and motion are never the only signal: every mark sits next to its state in words, so the mark itself is decorative for screen readers. Second, the eyes are the logo's eyes, always. We tried narrowing them to show sleep, and it read as a different creature, not a sleeping one. Now only the body dims while an octo sleeps. The eyes stay exactly as the logo draws them.

Colour is how you tell a crew of six apart at a glance, so there are twelve, chosen to stay distinct from each other on both light and dark backgrounds. There's no free colour picker on purpose: an arbitrary hex can vanish into the background or make two octos indistinguishable. And because people like their octos, there's a Save avatar button that exports the mark as a PNG.

Every octo gets its own folder

This is the change underneath everything, and the one we'd most recommend to anyone building agents on shared compute.

Each octo works in its own directory, /home/octo/octos/<name>. Every conversation and every routine of that octo runs there. Its AGENTS.md — the opening context the agent reads — lives there too, seeded with your account's instructions plus who this octo is and what it's for. After that the file is the octo's to keep.

The mechanism turned out to be a single field. Octomind's WebSocket protocol opens every conversation with a session frame; as of octomind 0.55.2 that frame takes a cwd. The cloud sets it to the octo's folder on every connection and ignores any value a client tries to send. Everything octomind resolves from the working directory then becomes per-octo for free: its instructions, its .agents/ tools and skills, and the project scope that memory is keyed on.

Folders also answered the machine question for you. A new octo joins the machine that already holds the most octos and still has room, so a crew shares one computer and one compute bill. A new machine appears only when none fits. A Small machine holds 5 octos, a Medium 10, a Large 20; Pro allows 10 in total and Max 30.

We're straight about the boundary: octos on one machine share a user and a container. A folder keeps work tidy; it is not a security wall. When a job needs real isolation — a client's credentials, say — give that octo a machine of its own.

Still a real computer, shell and all

The rebuild took nothing away from the people who want their hands on the machine. Every octo's Body tab has Open a shell here: a real terminal on its machine, already standing in the octo's folder. The machine has sudo and Docker, it can run your own image built from ours, and whatever the octo builds can go online at a live URL — 5 on Pro, 20 on Max.

The rest is where it always was. Machines, workflows, routines, the config editor and the full REST API sit behind Advanced, and the open-source runtime underneath is the same octomind you can run on your laptop. Octos are the front door, not a fence.

Chats reach an octo, too

Telegram, WhatsApp, Slack and GitHub now speak in octos:

• A direct chat reaches the octo you picked with "Send them here" on its Can do tab, or your most recent one. /octos lists them and /use switches.
• A group chat belongs to one octo. The owner binds it by messaging in the group; after that, everyone's messages reach that octo, but only the owner can run commands.
• Release on the octo's page frees a group again.

For developers

The public API follows the panel. POST /octos creates an octo and places it, making a machine when none fits; pass its octo_id when you start a conversation and the turn runs in its folder. GET /octos/:id/activity pages through what it did. The OpenAPI document at GET /api/v1/openapi covers all of it.

curl -X POST https://api.octomind.run/api/v1/octos \
  -H "Authorization: Bearer om_…" -d '{"name":"CI"}'

curl -X POST https://api.octomind.run/api/v1/machines/<machine_id>/sessions \
  -H "Authorization: Bearer om_…" \
  -d '{"octo_id":"<octo id>","message":"run the tests, fix what fails"}'

What we learned

• Let the market name your category. Dots told us what people will call this. We kept everything that makes ours different and gave it a name of its own.
• Name the thing people bring, not the thing you run. Machines and sessions were accurate. They were also our words.
• Make the invisible decision automatically, and show where you made it. Placement, the working folder, the specialist that answered: all automatic, all visible one click away.
• Constraints beat taste. "Fits on one laptop screen" settled more arguments than any mockup.
• Keep the brand's face. A mark people recognise is worth more than a clever state animation.

If you're on a cloud plan, every machine you have is already an octo, carrying its name, its conversations and its routines — open the panel and meet them. If you're not, Octomind Cloud starts at $20 for the first month. On ChatGPT Pro in Europe, the UK or Switzerland and still waiting for Dots? Your crew is ready now.