AI Multiplayer Mode

In Autonomous Growth Agent, I wrote about giving an AI agent the context and tools to help grow a business without you having to do every single sales and marketing step yourself.

But now we need to take it a step further and imagine everyone in the company doing it, not just you.

Sales people have agents. Product people have agents. Finance folks have agents. Your customer has one, too.

They’re all working on different pieces of the same problem. The customer wants something, somebody promised a date, engineering found a problem, and finance needs to know what it will cost.

Somehow, all of that information and decisions need to come together.

Today, the human often carries the information between those conversations. Copy this. Forward that. Explain the background again. Ask whether anybody has the latest version. Or point to some doc and throw it over the transom for someone else to figure out the details.

AI Multiplayer Mode is the next step that promises to make collaboration easier: people and their agents working together with enough shared context to move the work forward.

Here’s how we think about it.

Start with Shared Memory.

Shared Memory sounds more mysterious than it is.

One person or agent learns something useful, saves it in an approved place, and another can find it when needed. It’s basically a Google Doc. Think of a project folder with a running handoff note: what we know, what changed, who owns the next step, and where the evidence lives.

The software checks who can see the information before bringing the relevant parts into an agent’s chat. Your agent can keep private notes while sharing certain information with the rest of the group.

This shared memory gives the agent context without automatically retraining the underlying model. But AI agents and humans reading it provide something valuable. The Update. Instead of a never-ending stream of 1 on 1s and calls with way too many people in them. Now we just know that the agents have all that covered.

In the future, your Heads Up Display (HUD, for short) will tell you only the bits of relevant information at the right time when you need it. If you want, you can drill into to understand the reasoning or background on the information or the decisions.

“Launch moved to Friday” helps. “Launch moved to Friday because the customer approved the revised testing plan” helps the next person understand what would have to change to move it again.

How it works inside one company.

Now let’s imagine the team is launching a new product.

The salesperson’s agent records an approved customer requirement. The product manager’s agent checks it against the release plan. Engineering’s agent spots a missing feature. Finance’s agent checks the proposed cost against the budget.

They can work from a shared project record (e.g., Shared Memory) while keeping access limited to what each role needs. Note that there are security and data access permissions included by default. For example, joining the launch team shouldn’t expose everybody’s salary, private conversations, or unrelated customer accounts.

But then something happens.

Engineering discovers that the feature will take another week to harden before production release.

The agent updates the project record with the source and flags the people affected. Sales can prepare the customer conversation. Marketing can adjust the launch materials. The responsible person still approves a new commitment to the customer.

This is the benefit made real. We save a tremendous amount of time reconstructing what happened, and more time working toward what happens next.

We shift from inefficient busywork or administrative work to efficient value creating work.

Now, there are, of course, some housekeeping problems to solve. If two agents change the launch date at once, the system needs to flag the conflict instead of silently losing one update. ACID transactions protect the data, while version checks and conflict handling prevent one agent’s update from silently overwriting another’s.

The bigger issue is if a note is wrong, the correction needs to reach whoever relied on it.

Shared projects in ChatGPT and the newly launched Spaces (which is basically Google Docs where you can tag your personal agent) already provide a bounded place for people to work with common files, instructions, and conversations. The broader vision here adds coordination between people’s separate agents.

Giving everyone the same AI subscription doesn’t connect all of their private work automatically.

Now let’s explore what it means for agents to work between companies.

Now let’s bring in a customer and one of its suppliers, a manufacturer.

The customer’s agent sends the requirements. The manufacturer’s agent shares a delivery estimate. Your agent compares those against the launch plan.

Each company keeps its own internal memory. The confidential Shared Memory contains the information the parties have agreed to exchange: specifications, decisions, open questions, delivery dates.

The manufacturer doesn’t need sensitive financial information about your business. Nor does your customer need the internal debate about pricing. Your agent might know both but does not have permission to share it with either party.

This is where knowing who an agent represents matters. Can it suggest a date, or commit to one? Can it read a document, or pass it to a subcontractor? A message arriving from another agent doesn’t grant it authority.

It would start with one project and named participants. it would keep a record of who supplied each fact and when. It would agree on what happens when somebody leaves, access ends, or information needs to be removed. Revoking access stops future data sharing, and it certainly can’t reach into another company’s systems and erase information already shared.

That’s where AI safety and PROME’s care core comes in handy.

How it works among friends and families.

The same idea applies outside work.

Imagine four friends planning a trip. One cares more about price. Another one wants a direct flight. One person can only leave after work. But there’s one thing everyone agrees on: we’re tired of the incessantly pinging group chat.

Each person’s agent could add dates and personal preferences to a shared plan, compare options, and bring back only the decision points that each person needs to make. It could share available times without exposing the private calendars.

The group’s memory keeps track of the plan: which weekend is best, which hotel everyone agreed on, who still needs to confirm, and most importantly, why Carl still hasn’t paid. C’mon Carl.

These are examples of AI Multiplayer Mode. Once the trip is over, only meta data on preferences are saved. What happens in Vegas, stays in Vegas.

How the agents work together.

Shared memory is one piece. An agent swarm also needs a way to divide the work.

A lead agent can break a task into smaller jobs and bring the results together. One researches suppliers. Another checks availability. Another reviews the numbers. Different agents can have different instructions and tools even when they use the same underlying model.

Sometimes the lead stays in charge and asks a specialist for help. Sometimes it hands the task over. OpenAI’s Agents SDK supports both patterns.

Anthropic has described using a lead research agent with parallel workers and separate working contexts. It also describes patterns for saving work as external artifacts. Agents can divide a job and bring their findings back together.

Communication can be fairly ordinary: here’s the task, here’s the source, here’s my result, here’s what I couldn’t verify. A shared file or database holds the longer material. A short message points to the exact version. Clear fields help software track ownership and status without interpreting a long conversation every time.

You can also have one agent propose an answer and another challenge it. A reviewer can check the sources, run a test, or look for a missing assumption. Debate can expose disagreements worth investigating. A vote among agents still needs evidence behind it.

More agents also mean more coordination and compute. They can repeat work, miss a handoff, or reinforce the same mistake. The useful question is whether the team produces a better result for the time and money spent. Sometimes a single agent with the right tools is the better choice.

How this connects to training and alignment

There’s another kind of multiplayer happening in AI research: using interactions between models to help train them.

OpenAI’s hide-and-seek research trained agents through competition in a simulated environment. As teams adapted to one another, new strategies emerged. This is self-play: the other agents help create the challenges the system learns from.

That tells us something useful about learning through interaction. It doesn’t establish that an agent trained to win a game will respect a customer’s privacy or make a good business decision.

For alignment, the question is how to encourage behavior people actually want.

Anthropic’s Constitutional AI research used written principles to guide AI critiques and revisions, then AI-generated preference feedback for reinforcement learning. The principles and the training process shape which behavior gets rewarded.

OpenAI has also studied prover–verifier training, where one model produces solutions and another checks them. The research explores whether training that interaction can make correct reasoning easier to verify.

These are specific research methods with specific tests. They don’t imply that every chat assistant is constantly retraining itself through conversations with other agents.

During everyday work, agents can improve a workflow by saving a useful lesson, changing instructions, or proposing better code. A team can test that change against real examples, check for regressions, and approve it before wider use. Retraining the underlying model is a separate decision and process.

I think the same discipline matters in both places: define what success means, test it, keep the evidence, and retain a way to undo a bad change. Rewarding only speed or task completion invites the system to miss everything else we care about.

Where I would start

This is the direction we’re exploring with Shared Memory at Evergences. The developer beta provides public notes and private workspace tools. The planned pilot starts with two teammates, their agents, and one approved project.

That feels like the right unit to learn from.

Pick a job where people repeatedly explain the same background or wait for one another’s updates. Decide what can be shared, who owns each decision, and how you’ll know whether the work improved.

Then watch what happens when the next person can begin with the useful work already done.

That’s the part of AI multiplayer mode I’m most interested in. We each get help, and the work we do together gets a memory of its own.

— Sean