350 AI Agents Built on Orbit: From AI Second Brain to Agent OS

350 custom AI agents have now been built on Orbit.

That number means more to me than a milestone usually does, because agents are not where this started. We started with a much smaller problem and followed it until it turned into something much bigger.

This post is the story of how that happened, what Orbit has become, and how to build an agent on it that keeps running. And it's a thank you, because none of it happened without the people using it.

Where we are

• 350 custom agents
• 706 users
• 22 businesses running on it
• 4,000+ tools integrated
• 150+ AI harnesses connected
• 250K social engagements
• 235K page views

The numbers are nice. What matters more is how we got to them, and what they point at.

How it started: the context problem

We started by solving context for agents and the fragmentation between AI tools.

If you work with AI seriously, you know the feeling. One conversation in Claude knows your pricing. Another in ChatGPT knows your customers. A coding session in Codex knows the product. None of them know each other. Every new chat starts from zero, and you spend the first ten minutes explaining your own business to a tool that was supposed to save you time.

The models were not the problem. They were already good. The problem was that nothing held the context between them. Every tool was smart and none of them remembered.

So that's what we built first.

From AI second brain to company brain to agent OS

Looking back, Orbit went through three stages. We didn't plan them. Each one showed up because the one before it worked.

Stage one: an AI second brain

The first version was one memory that all your AI tools could read from and write to. Tell one tool something and the others knew it. Finish a piece of work in one place and it was there when you opened another.

That alone removed the re-explaining. It also showed us something we didn't expect: once the memory was shared, people stopped thinking about which AI tool they were in. The tool became a window. The memory was the thing.

Stage two: a company brain

A second brain is personal. A business is not.

As people put real work into Orbit, the memory filled up with things that belong to a company and not to one person: decisions, customers, results, files, the way things are done. Several people and several agents were now working from the same facts.

That changed what the memory had to be. It needed to know which facts are settled and which are just notes. It needed to replace an old version when a new one arrived, so nobody acted on last month's answer. It needed to be something you could trust without checking.

At that point it was no longer a second brain. It was what the company knows.

Stage three: an agent OS

Then the obvious question arrived. If the brain already knows the business, why are the agents still somewhere else?

So the agents moved in. You describe a job in a sentence and an agent shows up ready to do it, with the tools it needs already built in and the memory of the business already behind it. It runs on a schedule you set, or whenever you ask. Everything it does lands in one place you can see.

Memory turned out to be the foundation, not the product. What stands on it today is a complete agentic operating system.

What an agentic operating system does

"Operating system" is a big phrase, so here is what we mean by it. An agent OS does six things, and it has to do all six.

It has the context

Every agent starts with what the business already knows: who the customers are, what was decided, what worked last time. You don't brief an agent from scratch. It reads the same memory every other agent reads.

It stays up to date

Context that goes stale is worse than no context. On Orbit, agents write back what they did and what they learned. A new result replaces the older version of it. When something clearly improved an agent's results, it records that as a learning, and it reviews its own recent runs every 10 runs or 7 days. The picture of the business keeps moving with the business.

It keeps everything visible

Work you can't see is work you can't trust. Every run lands in one place. You can open an agent and see what it did, step by step, and what each step cost. Nothing happens in a tab you forgot about.

It flags decisions

An agent should not guess at things only you can decide. When it reaches one, a draft that needs your approval, a choice between two options, a connection that broke, it stops and puts the question in your Inbox. Routine work stays quiet. Decisions come to you.

It connects to any tool and system

An agent that can't act is a chatbot. Agents on Orbit come with more than 4,000 tools built in, with no API keys and no setup. They can use a real browser for sites that have no connector. You can add your own MCP server, start an agent from another system with a webhook, and send its results back out to your own.

It unifies context, work and AI

This is the part that matters most. Businesses don't need one more AI tool. They need the context, the work and the AI in the same place, behaving like one system. The memory knows the business. The agents do the work. The models, Claude, Codex, ChatGPT and more, are the engines. And a human stays in charge of all of it.

Infinite possibilities

We built Orbit around growth work first: finding customers, writing outreach, running content. That is still our focus and it's where most people begin.

But an operating system doesn't decide what gets run on it. Once the context, the tools, the visibility and the decisions are in place, the job is whatever you can describe. The verified agents in the Marketplace already go past marketing: there's one that prepares you for meetings, one that reaches out to investors, one that finds jobs and one that sorts your inbox.

That's what I mean by infinite possibilities. Not that Orbit does everything today, but that nothing about it is limited to one kind of business or one kind of work. Any business has context, repeatable jobs and decisions. That's all an agent OS needs.

We are so curious to see the use cases Orbitagents will enable. The best ones so far were not our idea.

New to this? What the words mean

Three lines in the numbers above need a translation.

• A custom agent is an AI worker with one job. You describe a job in a sentence (find me customers on LinkedIn, write my outreach, post my content) and an agent shows up ready to do it.
• A tool is anything the agent can act with: a search, a scraper, an inbox, a CRM, a social account.
• A harness is the AI program an agent runs inside, such as Claude, Codex or ChatGPT. Orbit sits above them, so agents in different harnesses share the same memory and report to the same place.

Six habits of an agent that keeps running

Building an agent takes a sentence. Building one you still trust a month later takes a few habits. These are the ones the product is built around.

1. One agent, one job

"Do my marketing" is a department, not a job. "Find 20 founders a day who posted about hiring an SDR" is a job. The narrower the job, the easier it is to see if the agent did it.

When you need more than one job done in a row, link agents instead of stretching one. That's what Workflows are for: one agent finishes and the next starts with what it produced. I covered how that works in the October update.

2. Give it an outcome, not a task list

A task list tells an agent what to do. An outcome tells it when it's done. "Five qualified conversations a week" lets the agent make sensible choices along the way. Every agent on Orbit has an outcome field for this reason.

3. Start from an agent that already works

A blank prompt box is the slowest way to start. The Marketplace has a Verified by Orbit section with agents built and tested by our team, each with a finished prompt. Install one, watch a run, then change what doesn't fit your business. You learn more from editing a working agent than from writing one cold.

4. Read the run, then correct the step

The hardest part of trusting an agent is that you can't see inside a run. Sequence fixes that. It draws each run as a chain of steps, so when a result is wrong you can point at the step that caused it.

• Open a step to see what it asked for.
• Take a step out if it was a waste.
• Leave a note on a step that was close but off. The agent is told at the start of its next run.

That turns fixing an agent from rewriting its prompt and hoping into a two minute correction.

5. Let it learn

Most agents start every run from zero. On Orbit, a learning stays. Learnings can also be shared with other agents, so what your outreach agent works out doesn't stay with your outreach agent.

6. Stay the boss

An agent OS doesn't replace the person running the company. It runs with you, not by itself. The agents that last are the ones with a human who reads the results and replies with corrections. If you run several at once, this guide to managing multiple AI agents is the next thing to read.

Build your first agent this week

You can go from nothing to a running agent in one sitting.

1. Sign up free. You get 100 credits and no card is needed.
2. Pick one job. Install a verified agent or describe the job in one sentence.
3. Tell it when to run. Say it in chat, for example "run every weekday at nine".
4. Read the first run. Open Sequence, leave one note on the step that was off, and let it run again.

Do that for one week and you'll know more about running agents than most people who only read about them.

Thank you

We went from an AI second brain, to a company brain, to an agent OS. Every one of those steps came from someone using Orbit for something we hadn't planned for.

So to everyone who signed up, built an agent, broke something and told us, or joined the community: you're shaping what this becomes. We're early, and it already feels like the way every company will work.

If you've been watching from the side, now is a good time to try it. Build the AI empire that runs with you, the operating system for Claude, Codex, ChatGPT and more.

Open Orbit