The big idea
The conversation lands on a simple inversion: today developers think of an AI agent as a feature you add to an app. Jason's bet is that agents become the workload itself — spun up in swarms, isolated in sandboxes, and orchestrated the way we orchestrate containers today. The unit of compute shifts from "a model call" to "an agent with a job."
The most striking part of the episode is the live demo: attacker agents trying to socially engineer a guarded agent into wiring money out of an account. It's a preview of a world where both sides of a fraud attempt are automated — and where defense has to be designed into the agent runtime, not bolted on.
Why this matters now
Every major lab shipped agent frameworks this year, and enterprises are moving from pilots to production fleets. The winners of that shift won't be decided by model quality — every team has the same models — but by who solves orchestration, isolation, and deception-resistance first. That's exactly the layer this conversation maps.
Key takeaways
- Swarms beat single agents for real work. One agent hits context and reliability walls; hundreds of narrow agents, each sandboxed with a small job, compose into something dependable.
- Isolation is the primitive that matters. Giving every agent its own sandbox does for agents what containers did for services — it makes failure, abuse, and blast radius manageable.
- Agent-vs-agent security is already here. The wire-transfer demo shows adversarial agents probing a guarded agent in real time. Guardrails have to survive automated, persistent social engineering.
- Big-company scale teaches small-company speed. An exabyte-a-day logs pipeline at Google taught Jason where infrastructure actually breaks — knowledge he now compresses into a single API.
- The leap isn't reckless if the foundation is boring. Leaving Google works when what you're building is the plumbing everyone will need, not a feature someone will copy.
Inside the conversation
From model calls to agent fleets
The episode frames the shift the way early cloud people framed VMs → containers: the interesting question stops being "how smart is the model" and becomes "how do you launch, watch, and kill ten thousand of them safely." Funky's one-call swarm API is a bet that developers want that abstraction, not another chat wrapper.
Security as the defining constraint
If agents can move money, file tickets, and touch production systems, then tricking an agent becomes the new phishing. The ride digs into why deception-resistance — not benchmark scores — will decide which agent platforms enterprises trust.
The ex-Google founder playbook
Six years inside Google's infrastructure taught a specific lesson: the hard problems are operational, not algorithmic. The conversation is a case study in taking scale scars from big tech and turning them into a startup's unfair advantage.
About Funky
Funky lets developers spin up hundreds of sandboxed AI agents with a single API call. Jason Jin founded it after six years at Google, where he built logging infrastructure processing over an exabyte of data per day.
Questions this episode answers
What is an AI agent swarm?
An AI agent swarm is many narrow, single-purpose AI agents running in parallel on a shared task — instead of one large agent trying to do everything. Each agent gets a small job and its own sandbox, so failures stay contained and the work composes reliably.
Why do AI agents need sandboxes?
Agents take real actions — calling APIs, writing files, moving data. A sandbox limits what each agent can touch, so a compromised or malfunctioning agent has a small blast radius. It's the same reason cloud workloads moved to containers.
What is Funky?
Funky is a developer platform founded by ex-Google engineer Jason Jin: one API call spins up hundreds of AI agents, each in its own sandbox. It treats agents as a scalable workload — like serverless functions, but for autonomous AI work.
