Multiplayer AI with receipts.

A platform where teams of AI agents and people do sustained, useful work together. You set up the team: its roles, the tools and information it can use, and the rules it works under. Then you hand it real work, and it keeps going for hours, days or weeks.

While the work runs, AgentUltra keeps track of five things for you, so nobody has to guess:

• Who owns each task. Every task has exactly one agent or person responsible for it at any moment. Two agents never do the same job or overwrite each other, and once work is handed over, the previous owner can’t touch it.
• Who is allowed to do what. Your policy decides what each role may do. AgentUltra checks it at the moment an agent acts, not only when the work was planned, so a change you make applies to the very next step.
• What people signed off on. An approval covers the exact version the person saw. If anything changes afterward, it needs a fresh sign-off.
• Where each result came from. Results carry their sources and the steps behind them, so anyone can see why, not just what.
• What actually happened. Every action that reaches the outside world, like a payment, an email or a change in another system, is tracked until its result is confirmed. If a result is unclear, it’s marked unclear and checked, never quietly retried.

So at any moment you can answer the questions that matter: who is doing what, who allowed it, what was approved, and what really happened.

Work that’s too big, too long or too important for a single chat. For example:

• Clearing a queue of exceptions before a deadline, with the hard cases routed to the right person.
• Preparing and submitting paperwork across many systems, like prior authorizations or insurance claims.
• A migration, cleanup or investigation that takes weeks and touches real systems.
• Research and due diligence where every claim needs a source.
• A surge of customer requests, worked around the clock.

You set the goal, the rules and who signs off. The team plans the work, splits it up, does it, and brings decisions to the right people with the evidence attached. The In practice section walks through four of these step by step.

Chat assistants and coding agents are great when one person works on one task in one sitting, checks the answer and decides what to do with it. AgentUltra is for the work that doesn’t fit in that window:

• A team, not one helper. Many agents and people, each with a role, working on the same job at once without stepping on each other.
• Work that outlasts the conversation. It runs for days or weeks and survives crashes, restarts and closed laptops.
• Rules that are enforced, not requested. Limits are checked by the platform at every step, not written into a prompt and hoped for.
• Sign-offs that mean something. An approval is tied to the exact version a person reviewed.
• A record you can stand behind. Every action, decision and outcome is written down as it happens, ready for whoever asks later.

Most AI tools set limits by asking the model nicely: a line in its instructions that says “never do this.” A model can misread that, lose track of it deep into a long task, or be talked out of it by something it reads. AgentUltra doesn’t depend on the model behaving.

Every action an agent takes, whether reading a record, sending a message, spending budget or changing another system, passes through a checkpoint that AgentUltra controls, outside the model. At that moment it checks your current policy:

• If the action is allowed, it goes ahead and is recorded.
• If it needs a person, it waits for that person to approve the exact version.
• If it isn’t allowed, it doesn’t happen, whatever the model “thinks.” The attempt is recorded too.

Agents can’t raise their own authority. They can only ask for more, and granting it is a decision a person makes, on the record.

In a chat tool, the work lives in the conversation. Close it, or let it run too long, and the thread is gone. In AgentUltra, the work lives in a durable record: the plan, who owns each task, what’s done, what’s waiting and why. Every step is saved as it happens. That changes what’s possible:

• An agent can wait for a person, a document or an outside event without tying anything up. When the answer arrives, the work picks up where it stopped, with its full context.
• A task can move from one agent to another, or to a person and back, without losing its history.
• Time, money and requests are metered across the whole job, not per conversation. When a limit is reached the work stops until someone grants more, so a long job can’t quietly overspend.
• You don’t have to babysit it. Check in whenever you like and you’ll see current progress and anything waiting on you.

The work keeps its place. Here’s what happens in each case:

• You close your laptop or lose your connection. Nothing stops. The work doesn’t run in your browser; it runs on AgentUltra. When you come back you see where things stand, including anything waiting for you.
• An agent crashes or goes silent mid-task. Its hold on the task runs out, and the task goes back to the team with everything done so far. Another agent, or a restarted one, carries on. If the old agent wakes up later, it can no longer act on work it no longer owns, so two agents never write over each other.
• The connection drops during an outside action, like a payment or an email. AgentUltra doesn’t guess, and it doesn’t blindly try again. The action is marked “outcome unknown,” checked with the other system using the action’s own ID, and recorded as it actually turned out. That’s how nothing gets paid or sent twice by accident.
• A server restarts. Each change to the record is saved all at once or not at all, so the record is never left half-updated. Work continues from the last saved step.
• You cancel the work. New steps stop right away. Steps already underway finish or are tracked until their outcome is known, and the job isn’t marked done while anything is still running.

Yes. You decide what agents may do on their own and what needs a person. Sign-off requests arrive with the evidence attached, for the exact version that will go out. You can watch any work as it happens, redirect it, pause it or stop it. Watching never changes anything by accident; only an explicit instruction does. When you pause or stop, you’re told exactly what has stopped and what hasn’t yet. And when you change the rules, the very next action follows the new ones.

A framework gives developers parts for building an agent. Everything that makes agents safe to trust with real work is left for your team to build and maintain: who owns which task, what each agent may do and when that’s checked, sign-offs, tracking actions to their results, and a complete history.

AgentUltra is where agent teams actually do the work, with all of that built in. Every agent runs in AgentUltra’s own runner, so the same checks and records apply to every step every agent takes, not only the steps someone remembered to wire up.

We’re opening early access in stages. Request access below and tell us about the work you’d hand to an agent team. We’ll reach out as places open.