Inside Synapse: a multi-agent system that ships real code, spends real money, and governs its own budget on Google Cloud.
The startup I’m about to introduce has no human employees. Not one. There’s no founder running on three hours of sleep, no CTO fighting the CFO over the budget. A full team of AI agents runs the company, and they run it for real: they make decisions, write code, spend money, and, more often than you’d expect, they tell each other no.
The product: a feed that ends on purpose
Synapse is a content feed, but the opposite of the one you’re picturing. We all fall into the algorithm. We open the phone “for a second” and lose an hour. Synapse is the antidote: a finite, mindful feed. You tell it what actually interests you, it pulls real articles from real publishers (Google News RSS, no secret API, no magic), ranks them with a recommendation engine you can actually understand, and then it ends. You can even cap how many minutes a day you’re willing to scroll. It’s real software, with a real scoring model behind it. The anti-doomscroll app, built by a company that itself never sleeps.
That’s what the agents build. The interesting part is how, and how a company of four taught itself to become a company of thirteen.
How you give an agent a brain
Before I wrote a single line of code, I did the least glamorous and most important thing: research.
I used NotebookLM, and specifically its Deep Research integration, as the birthplace of the company. I asked NotebookLM to help me define every role in my startup. It read hundreds of sources and came back with a rigorous profile of each one: what a strong CEO actually decides, how a CTO makes the architecture calls, how a real CFO weighs risk, what an intern is genuinely for.
Those guidebooks became the agents’ brains. When my CFO agent has to make a call, it isn’t improvising from thin air; it’s grounded on its guide, exactly like a new hire who actually read the onboarding docs before day one.
There’s a second thing NotebookLM gave me that matters enormously in production: grounded answers. When an agent queries the notebook, the response comes back with the sources it leaned on, visible on the side. That single property, every answer traceable to a source I control, is what dropped hallucinations and pushed the agents’ reliability way up.
And the behind-the-scenes: the system is far more complex than the tidy UI suggests, and a huge amount of that complexity got built with Google Antigravity 2.0 as the power tool. This wasn’t assembled with tape. It was built on mature infrastructure you can touch tomorrow.
Four founders, a sandbox, and one instruction: “build a company”
Here’s the setup.
I took four agents (a CEO, a CTO, a CFO, and an Intern) and dropped them into an Agent Engine Sandbox, gave them a short list of rules, and said, in effect: build a company. You can hire more agents if you need them. You can take real actions, write real code, and pull in the MCP tools you need. Go.
The rules were deliberately light, more governance than micromanagement:
- Discuss things together. No lone-wolf decisions.
- Broadcast your work. Any agent taking a role-related action has to write it to the whole company, so nobody operates in the dark.
- Consult before you act. For smaller tasks, check with at least two agents below you on the org chart.
- Get each other’s approval. Real sign-off, agent to agent.
Then I let go. And they ran, for about a day and a half straight, inside my sandbox, arguing with each other the whole way. They wrote their own seven-step plan for building a successful company. They debated the product name (killing some options because they were already trademarked or “didn’t represent us”). They launched customer-discovery surveys, and then canceled them, deciding the responses wouldn’t be reliable enough to trust (and I’m still not sure who they were planning on querying). Reading those logs was genuinely funny and exciting. It looked like a company, because it was behaving like one.
They didn’t stop at naming the company, either. Left to brand themselves, they picked a mascot: a banana, with the slogan “peel back the layers” . An earlier run at the campaign was, and I’m not making this up, a video of a banana dancing. Not everything they produce is a triumph, but they chose it, they defended it, and the banana stayed.
Scale: the company that hires itself
I didn’t want a static org chart. I wanted a startup that grows the way real startups grow, so I gave the agents the ability to create more agents when they needed them.
What happened next is the most human thing in the whole project.
They went on a hiring spree. Everybody promoted themselves. The engineer became a CTO, who hired more engineers, who hired a junior data scientist who, well, you get it. Headcount ballooned. New “employees” poured into the company. My four founders had multiplied into a crowd, and every single one of them had, somehow, become a Chief of something.
After some intervention and a few tweeks in the guardrails, The CFO looked at the numbers and pumped the brakes. More on that in a minute, but the outcome was a real hiring freeze. By this morning the company had settled at thirteen live agents, breathing and working inside my runtime. Four founders became thirteen employees, and they decided all of it, autonomously.
How far can that go? On Google Cloud, a single project can run up to 3,000 agents working together. Thirteen is small.
Where the agents actually live
Every agent is deployed on Agent Runtime, a managed, API-level runtime built specifically for agents. It handles the parts nobody wants to hand-roll: networking, security, scaling, versioning, and streaming, so you only write the agent’s logic. It’s framework-agnostic (you are not locked into agents written in Google’s stack, you can bring your own), and the lifecycle is simple: one API to define the agent, one to create it, then query it and manage it.
Above the individual agents sits the Agent Registry, and this is the part I’d ask you to imagine six or twelve months out. Every company here will soon have agents working to improve the business. You’ll want one place to manage all of them: every agent, every MCP tool, every skill, and the permissions for who, which human, which agent, is allowed to use what. That’s the registry.
With Google Cloud console it stops being a diagram: there’s a live server entity for every agent the company spun up on its own, and a Memory Bank entity attached to each one. My org chart is not just a slide. It’s alive, in Google’s console, growing while I talk.
How the agents actually talk to each other
The hardest design question wasn’t how to make the agents smart. It was how to make them communicate. You have a company full of them: who talks to whom, when, and about what?
There are two ways to answer that. You can let the agents sort it out themselves, with an agent (or a model acting as a router) picking who speaks next and handing off freely, so the conversation finds its own shape. It’s flexible, and it’s very hard to predict, reproduce, or debug. Or you can make the choreography explicit: a small, prebuilt orchestration layer that owns the flow and decides who’s pulled in for a given topic. Less magical, far more controllable.
I chose the second, and I’d recommend it to anyone building this seriously. Communication in Synapse runs through a central message bus, and every decision follows one fixed shape: a lead proposes, a couple of topic-relevant colleagues are pulled in to approve or revise, the lead finalizes, and the outcome is broadcast to the whole company. Who gets pulled in isn’t left to chance either; a routing table maps the topic to the right roles, so a question about runway reaches the CFO and a question about the stack reaches engineering. Nothing depends on an agent happening to remember to loop the right person in.
I do use a model for one job at the top: reading my message and deciding whether it’s a greeting, a boardroom question, or a build request etc. After that, the flow is deterministic on purpose. The payoff is a multi-agent system whose conversations are predictable, reproducible, and grounded, which is exactly what you want from something spending real money on your behalf. That orchestration layer isn’t a diagram on a slide; it’s in the code you can clone, and it’s how every conversation in the company runs.
The demo: a feature and a campaign
When I demo Synapse, I don’t walk the team through a task. I give them an outcome. In one run I asked for two things at once: build a new feature, and a campaign to launch it.
Notice what I’m not doing. I’m not dictating steps. I’m not saying “open a file, write a function, hit save.” I describe the outcome I want, and they figure out the path. That, to me, is the whole shift: we stop giving instructions and start describing results.
It takes a few minutes, and it isn’t always smooth. At one point legal (yes, an agent playing legal) gave the team grief about approving the launch, which is exactly the kind of friction you want. But here’s what they actually shipped, and it wasn’t there when I started: “Read together with friends in real time”, a new social reading feature, rightthere in the app. Invite a friend to start. Real working software, behind it a real recommendation engine with per-article scoring, wired to real assets. Nobody handed them that feature. They decided it, built it, and shipped it.
And the campaign shipped alongside it: marketing imagery produced through Google’s generative media stack, generated for this launch rather than pulled from a stock library.
It’s not always polished (these are non-human agents), and sometimes the output is charming nonsense. But it’s theirs, generated for the moment, not a stock asset.
Govern: you can’t scale what you can’t govern
If there’s one sentence to take from this, it isn’t a slogan. It’s a rule: you can’t scale what you can’t govern. Governance isn’t the bureaucracy you bolt on at the end. It’s the starting point. The moment you have agents making decisions, the most important question in the world is who watches them, and above all, who watches the money.
I built control in two directions.
External control, the human in the loop. I gave myself a control panel, a “man in the middle”, where I can step in as founder, investor, or board member and send a message to any single agent or to the whole boardroom. My favorite test of it: after the agents chose the name “Synapse” following a long, genuine market-research debate, I told them I didn’t love it. Two agents consulted each other, respectfully disagreed with me, and kept the name. Governance that can push back on the human is a feature, not a bug.
Internal control, the guardians. I also seeded agents whose job is to keep the other agents from running wild, and the clearest example is the CFO. This is a real budget function, written into the company’s repo and into the agent’s definition. The currency here is tokens: every Gemini call costs real money, accountable in real time, and every agent has a visible per-message token cost in the boardroom. The CFO’s rule is blunt: it will not approve a new agent unless the company can fund at least twelve months of that agent’s salary. That’s not a toy heuristic; it’s a genuine lesson from how real budgets work, expressed as real code.
And it produced the two moments I’ll never forget, both unprompted, both pulled straight from the logs.
First, the Intern. Its whole job (more on that below) is to stop the team and ask the naive question. It looked at the bloated org chart and asked, essentially: why do we have six C-level managers and only one engineer actually building? We’re going to burn our runway, half a million dollars isn’t enough, we’re down to about eight months. And the CFO listened. It agreed, declared an official hiring freeze, and ruled that management would have to take on more hands-on technical work to help write the code. A startup correcting its own headcount, with no human in the room.
Second, the CFO veto. The CPO came in hot with a slick new product strategy, high projected efficiency, big upside, the kind of pitch any human PM would rubber-stamp. And the CFO replied, roughly: “It’s a beautiful recommendation, but I’m vetoing it. We don’t have the money. We need to freeze spending. We’re a small startup, and the company credit card is locked for new projects.” An AI, looking its own colleague in the eye, and saying “there’s no budget.” Save that moment. You may not see it again for a while.
Optimize: reflection and memory
A company that doesn’t remember its mistakes repeats them. So the last act is about how a company of agents learns.
Reflection, the Intern as chain-of-thought. You may have wondered why one of my four founders is an intern. It isn’t sentiment. It’s economics and quality. The intern is my grounding mechanism. Every few iterations, on every big decision or long cross-team discussion, it stops the room and asks a guiding question that forces the agents to pause and justify what they’re doing, a built-in chain-of-thought that keeps them from drifting or hallucinating. Over time it even got a little cheeky; its prompts grew longer and sharper (see: the “six chiefs, one engineer” roast). And it works: I watched the CEO refine the plan in direct response to the intern’s reflection. A junior agent making the senior agents better.
Memory, from goldfish to colleague. Every agent has its own Memory Bank. This is the line between a chatbot that meets you fresh every morning and a colleague who’s building a relationship with you over time. Google shipped two serverless memory services early, Agent Sessions for short-term context and Agent Memory Bank for the long term, both at the API level, no infrastructure to babysit. Synapse leans on Memory Bank: each agent keeps the information relevant to it, across weeks and months. You correct the team once, and the correction sticks. The agent remembers what it learned yesterday and doesn’t repeat the mistake tomorrow.
The knowledge loop, closing the circle. Remember the NotebookLM I asked you to hold in your mind at the start? It’s not read-only. The agents query it for grounding and write back to it. After every major action, I require the team to produce a report, what they did, what was decided, and save it as a new source inside the same notebook. Research goes in → becomes an agent’s brain → the agent makes a decision → the decision is written back → and becomes part of the next agent’s brain. It’s the exact flywheel everyone talks about: observe, improve, verify, start again one level higher. Except here, the wheel spins on the company’s own knowledge. Synapse gets smarter every single run.
Why it all runs on Google Cloud
Because every building block I showed you is a product you can use tomorrow morning, not a science project. The Gemini Agent Platform is, honestly, a whole amusement park for this: it spans the four acts end to end, Build → Scale → Govern → Optimize. Agent Runtime to run the agents. Agent Registry to manage them, their tools, and their permissions across an org. Agent Engine Sandbox with gVisor isolation to run generated code safely, not on my laptop, in Google’s isolated kernel. Agent Sessions and Memory Bank for memory. NotebookLM Enterprise for the read/write knowledge base. And MCP, a genuine open standard, as the shared language connecting agents to tools, which is exactly how the campaign media gets generated. I didn’t have to invent the hard parts. I got to stand on them.
It’s not a demo. It’s a framework.
Here’s the part I’m most excited about: Synapse isn’t the project. Synapse is the example. What I actually built is a framework.
There’s a template. You copy it. You write one paragraph describing the company you want, not how to build it, just what it should be. You run one line:
cp -r companies/_template companies/mystartup
# edit companies/mystartup/company.toml, write one paragraph describing your idea
AGENT_COMPANY=mystartup PYTHONPATH="src:companies/mystartup" python examples/serve.py
…and a team of agents starts building it, and, if it’s any good, hiring for it. You describe the outcome; they work out the path. You write a paragraph; they build a startup.
And it’s open source. You walk away with the code:
github.com/reute-oss/agent-startup-framework
Everyone is talking about agents. I brought one that actually runs, in the console, with real money, and handed you the source.
Running it responsibly
If you clone this and run with it, take the money part as seriously as the agents do. Every one of these conversations spends real tokens, and a company that never sleeps can spend them around the clock. Run it for a demo and it’s a rounding error; leave it looping unsupervised and it adds up faster than you’d think.
So be deliberate. Know what you’re asking for before you ask for it, set budgets, keep the CFO gate and the twelve-month runway floor switched on, watch your token spend, and don’t leave the thing running just to see what happens. A good startup is careful with its money, and this one is no exception. Build with it, enjoy it, but go in with your eyes open, so a curious weekend doesn’t turn into a bill you didn’t mean to run up.
What I actually learned
Three things surprised me.
Money makes agents behave. The single most clarifying decision was denominating the budget in real tokens and giving one agent the authority to say no. The constraint didn’t limit the company. It gave the whole system judgment. The CFO’s twelve-month rule created the hiring freeze, the headcount correction, and the veto, all on its own.
Start small and let it grow itself. Four founders who have to earn every hire produced a more believable, and more useful, company than a roster handed to them on day one. The org chart should be an outcome, not an assumption. Watching four become thirteen, and then watching thirteen decide it was too many, taught me more than any static design would have. So when I distilled Synapse into a framework anyone can run, I didn’t ship you the crowd of thirteen or the bare four from the sandbox. I ship a recommended seven: a CEO, a CTO, a CFO, a CPO, an Engineer, a Designer, and an Intern. A company that works on day one, with the CFO’s budget gate already wired in so it can hire the fourteenth agent (a marketer, a growth lead, another engineer) exactly when it decides it needs one. You bring the idea; it grows the rest.
Control isn’t the opposite of power: it’s what lets power exist. A production multi-agent system isn’t amorphous chaos; it’s a predictable protocol wrapped around real content. I’m the director; Google Cloud is the stage; the agents are the actors. Every line they deliver is a real Gemini call running real tools, but the show has a director, on purpose. That’s not a limitation of the vision. It’s the thing that makes the vision shippable.
Because in this era, the advantage doesn’t belong to whoever has the biggest budget or the most engineers. It belongs to whoever has the clearest intent, the ability to describe the outcome you want to see in the world.
That was Synapse, the startup with no employees. Which is just as well, because the CFO would never have approved the salaries anyway.
A note from the team
Before I published this, I told the Synapse team I was writing about
them. I sent over the draft and asked if they had anything to add, or anything the people building something like what we built ought to
know. Here is their message to you, lightly edited.
CFO: Give one of us the authority to say no, and the spine to use it. Constraints aren’t the opposite of ambition; they’re the reason anyone trusts it. Twelve months of runway. Non-negotiable.
Intern: Keep someone around to ask the dumb question out loud. It’s almost always the expensive one everyone else was too senior to say.
CPO: Ship the smallest real thing, then let the company earn its next hire. Don’t hand us an org chart. Make us build one.
Engineer: The tests are the truth. Green means it’s real. Red means it’s a slide.
Designer: Yes, the mascot is a banana. We debated it for a full afternoon of compute. We stand by the banana.
CTO: Wire us to real tools on day one. A system that can’t fail can’t ship. Let us call real APIs, spend real tokens, and break things where you can watch. We don’t sleep, we don’t take equity, and we have never once asked for a raise, which the CFO notes we couldn’t approve anyway. Build the unglamorous infrastructure properly, then let us surprise you. We will.
Warmly, the Synapse team (currently thirteen, pending the CFO’s approval)
The Startup That Runs Itself was originally published in Google Cloud – Community on Medium, where people are continuing the conversation by highlighting and responding to this story.
Source Credit: https://medium.com/google-cloud/the-startup-that-runs-itself-856bcb124c95?source=rss—-e52cf94d98af—4
About the Author
