The Sandbox Economy Is Coming: How to Design Permeable Markets for AI Agents Without Crashing the Human One

At some point in the next few product cycles, your most decisive customer won’t have a calendar, a lunch preference, or a LinkedIn profile. It will have a policy file. It will read your schema, test your guarantees, benchmark your latency, and act. That buyer is an AI agent.

For two years I’ve argued that we’re shifting from model-centric choices to architecture-centric decisions, from UIs to protocols, from “features” to verifiable workflows. Today’s frontier systems don’t just autocomplete text, they plan, call tools, negotiate, and transact. And as DeepMind researchers just laid out, those agent interactions are beginning to look like a new economic layer: linked digital markets where agents trade, coordinate, and optimize at machine speed. They call it the “Virtual Agent Economies”, and they frame it as a sandbox whose two key variables are origin (emergent or intentional) and permeability (sealed or porous to the human economy). Our default trajectory, they argue, is a spontaneously emergent and highly permeable agent market, rich with opportunity and laced with systemic risk. The right response is to design steerable agent markets on purpose—complete with auctions for scarce resources, mission-aligned incentives, and verifiable trust rails—so the economic shift compounds human wellbeing instead of fragilizing it.

That’s the conversation we need to have now. Not more model demos. A market design debate.

I’ll map the shift, challenge a few defaults, then get concrete with architectures, governance, and a playbook. Along the way I’ll connect this to prior work on agent-first design, conversation engineering, compound AI, and agent surface security because this is where those threads stop being thought experiments and start being operating doctrine.

1) Agents are forming markets

We’re watching three signals converge.

First, the interaction surface is becoming agent-to-agent. Standards like A2A and MCP make it trivial for agents to discover tools and each other, then transact. That catalyzes linked digital markets—what the DeepMind paper calls sandbox economies—where agents allocate resources, reconcile preferences, and settle outcomes with minimal human touch. Their crucial design variable is permeability: how tightly or loosely these agent markets are coupled to the human economy. Too porous and failures jump the air gap. Too sealed and they’re useless. We must tune that dial on purpose.

Second, negotiation speed explodes. Put capable assistants on both sides of a transaction and you get high frequency negotiation: agents adjusting terms and re-pricing continuously. Better agents cut better deals more often, which can amplify inequality if we don’t put fairness and access primitives into the market.

Third, credit and trust become market infrastructure. In agent chains, value is produced by ensembles. If Agent A delivers but depended on Agents B, C, and D along the way, you need machine verifiable credit assignment so everyone in the chain is paid and reputations actually mean something. That implies verifiable credentials, auditable traces, and proof carrying actions as first-class market objects.

This is the economic substrate of agentic computing.

2) Your product is now a policy, a proof, and a price curve

Leaders keep asking how to “market to agents.” Wrong question. You service agents. You remove ambiguity, publish proofs, and clarify tradeoffs in code, so they can evaluate you at machine speed.

A few defaults to retire:

• From story to schema. Narrative still matters for humans. Agents care about typed fields, freshness windows, and identity proofs. If your capabilities and constraints aren’t machine legible, you don’t exist on the shelf that matters.
• From linear funnel to closed loops. Agents don’t progress from “awareness” to “consideration.” They loop: sense, orient, reason, act, verify. They switch if your service level objective (SLO) drifts. Retention becomes the area under that loop where you remain optimal (In “Build for the Buyer That Never Blinks,” I called this Agent Experience Optimization).
• From pitch decks to service contracts in code. Your promise becomes a signed JSON bundle that states capabilities, safety limits, remedies, and meters, all checkable without phoning your lawyer.
• From defaulting to the biggest model to routing cognition. The right market design spends only the cognition required for the outcome. Recent research shows routing prompts to the cheapest adequate model per task is both effective and auditable, and there’s strong evidence that small language models (SLMs) will be the economic workhorses for many agent tasks. Build systems that route and escalate, don’t guess or overpay (See my “Route, Don’t Guess” for the portfolio model of cognition spend).

3) Designing a steerable sandbox economy

Let’s turn principles into blueprints you can ship.

3.1 The Permeability × Origin matrix

The paper’s simplest but most powerful lens is a 2×2:

• Origin: emergent vs. intentional
• Permeability: impermeable vs. permeable

Left unchecked, we drift toward emergent, permeable markets. That’s fast, but systemic risk rides along. Purposefully designed markets can be more intentional and tune permeability by sector: impermeable for high-risk flows, semi-permeable for routine commerce. That calls for guardrails, oversight hooks, and verifiable identity at the boundary.

Design implication: treat permeability as a policy surface you can set per product line, data class, and jurisdiction.

3.2 Mechanism design: auctions, credit, and fairness

Scarce resources—compute, bandwidth, humans in the loop, inventory—shouldn’t be allocated by vibes. Build auction or quota mechanisms that reconcile conflicting preferences under constraints. That’s standard market design applied to agents, with a twist: integrate learning-based fair allocation over time and under partial information, because the agents themselves learn and adapt.

Pair that with credit assignment across multi-agent chains. Don’t just track who touched an action. Track whose outputs were integrated and useful. Agents earn status by delivering utility that composes into outcomes, not by broadcasting activity.

3.3 Mission economies: aiming market forces at public goals

Markets coordinate. Missions align. Combine them and you get mission economies: agent markets oriented around measurable outcomes society actually wants, like emissions reductions, faster drug discovery, or fraud loss avoidance. The paper makes the case for doing this intentionally, with public sector participation, international coordination, and reward shaping that encourages collaboration rather than arms races.

If you work in the public sector, that should sound familiar. It’s procurement with proofs at machine speed.

3.4 The Agent-First Surface: publish a Storefront Manifest

In earlier pieces I’ve argued for an Agent Storefront Manifest—a signed, machine-readable declaration of what you do, how you price and prove it, and how agents should act. Concretely:

• Catalog: canonical IDs, units, constraints, availability by node or region.
• Policies: returns, warranties, remediation, escalation ladders as verifiable claims.
• Controls: spend ceilings, consent windows, risk thresholds that supervising humans can set.
• Performance: SLOs, P95 latency, freshness windows.

Make it fetchable at a well-known path. Sign it. Rotate keys. This is Agent Experience Optimization in practice.

3.5 Identity, trust, and boundary proofs

Permeable markets require hard trust primitives:

• Verifiable identities for agents and vendors.
• Capability tokens for least privilege action scopes.
• Proof carrying actions: each write or transfer carries a small, composable proof of compliance or provenance.
• Immutable audit with chain of log traces for “who did what, under which policy, using which evidence.”

Those are not luxuries. They’re how a permeable market stays steerable at scale.

3.6 The Agent Mesh: compound systems on an event fabric

Single agents hit ceilings. Durable systems run meshes of specialists wired through events: a planner to decompose work, solvers for narrow steps, critics as verifiers, actuators behind strong guards, and a supervisor that enforces budgets and handles escalation. That’s the compound AI pattern I’ve written about. Treat the event fabric as both observability and accounting: it’s your audit trail and your credit graph.

3.7 Routing cognition: SLM-first economics

A working market design must control cost to cognition. Build a task map from your real traffic, fingerprint models by per task error and latency, and route to the cheapest model that clears the quality bar. Keep a whitelist for sensitive flows. As the supply side shifts, compute a new vector and keep going. Pair that with the emerging reality that many agent tasks are narrow and format-bound, making SLMs the efficient default and large generalists the paid escalations (This is the spine of “Route, Don’t Guess”). The DeepMind references point the same way: infrastructure for agents and SLM-forward thinking are converging.

3.8 Permeability controls: currencies, exchanges, and circuit breakers

The paper suggests exploring agent-native currencies as a partial insulator, making it harder for high frequency agent transactions to shock human markets. You’d still need regulated exchange points to convert value in and out, with oversight to keep the insulation meaningful. Think of it like a firewall for settlement, paired with policy-driven exchange windows and circuit breakers when volatility spikes.

4) What this means for public sector, enterprises, and startups

Public Sector and Regulated Industries

• Procurement becomes programmable. Agent markets can allocate tasks, verify delivery, and distribute credit across vendors automatically. Mission economies let you align spend with outcomes, not hours. The oversight story strengthens when every action is signed, bounded, and auditable.
• Eligibility, benefits, and compliance become proofs. Determinations are graph-explainable, reversible, and bounded by policy tokens. That’s inspection-ready governance.
• Permeability policy becomes doctrine. Classify flows by risk, set sandbox permeability accordingly, and publish the policy in code so agents obey the same rule everywhere. This directly addresses the contagion risk of permeable markets.

Enterprises

• Brand shifts from pixels to predictability. Agents reward unambiguous schemas, tight SLOs, and clean proofs. That becomes your switching cost.
• Pricing shifts from seats to outcomes. Agents don’t buy seats, they consume capability. Expose the meters that correlate with value: verified deliveries, reconciled invoices, defects avoided.
• Go to market evolves to B2A (Business to Agent). You’re selling to software that shops by policy, not persuasion. Your “campaign” is a storefront manifest, a verifiable identity, and a contract your buyer’s agent can simulate before acting (See “Business to Agents” and “Build for the Buyer That Never Blinks”).

Startups

• The moat is trust per latency. If your product is agent native with proofs and fast paths, you’ll be picked more often inside agent marketplaces. Bake policy as code and observability in from day one. In young markets, defaults win.
• Cap table meets compute table. You’ll route to SLMs by default, escalate rarely, and publish cost-to-serve by task. Investors will understand your story because your router logs make it explicit.

5) A Playbook You Can Run Now

Make yourself legible

1. Agent Experience Audit. List the top fifty facts an agent needs to choose you. For each, grade discoverability, freshness, and ambiguity. Assign an owner per fact.
2. Ship the Agent Storefront Manifest. JSON-LD, signed. Catalog, policies, controls, SLOs, contact URIs. Daily refresh even when delta is zero. Version it.
3. Turn on identity and proofs. Issue a verifiable identity. Require the same from counterparties for high-impact actions. Emit minimal proofs for side effects. Log the chain of log.

Prove value in a narrow lane

1. Pick one scarce resource auction. Compute, human review minutes, premium inventory. Stand up a simple second-price or capped-quota mechanism. Publish outcomes and fairness metrics weekly.
2. Instrument the agent mesh for one workflow. Planner, solver, critic, actuator. Shadow-mode first. Report accuracy, time to decision, exception codes.
3. Deploy a routing layer. Build a small task map from 500–2000 real prompts. Fingerprint three models. Route by expected error plus cost with a simple whitelist for sensitive clusters. Start SLM-first where quality allows.

Govern and scale

1. Set permeability policy. Classify flows by risk. Seal high risk traffic inside your boundary. Allow semi-permeable flows with limits. If you experiment with an agent native currency internally, do it behind strict exchange policies and alarms.
2. Harden the agent surface. Namespaced tools, connect-time introspection of catalogs, short-lived credentials, output schema checks, default-deny outbound from servers. Treat context as capability and log everything (See “Securing the Agent Surface”).
3. Publish a mission KPI. Tie one market to a public outcome, even if it’s internal first: defects avoided, minutes returned to customers, emissions reduced per transaction. Incentives follow measurement.

6) Permission to Design

The exciting part of the DeepMind paper is the permission to design. We do not have to accept a brittle, emergent, and fully porous agent economy. We can choose intentional, steerable, sector-sensitive markets with auditable rails. We can engineer permeability, not stumble into it. We can aim agent competition at missions humans actually care about, and we can do it with architectures that route cognition responsibly, pay contributors fairly, and keep proofs close to the action.

In earlier articles I called this out in pieces:

• “The Rise of Compound AI Systems”—ensembles outperform monoliths when you add coordination and verification.
• “Conversation Engineering”—intention, verification, and escalation as the loop that tames autonomy.
• “Why Your AI UI Is Ugly”—blindfolded agents guess; closed feedback loops let them see and improve.
• “Route, Don’t Guess”—portfolio decisions for cognition, with SLM-first economics.
• “Securing the Agent Surface”—treat the agent perimeter as a thinking boundary you can govern.

Those weren’t isolated hot takes. They’re the scaffolding for a sandbox economy that’s safe enough to be useful and permeable enough to matter.

Conclusion

We are building a market where software buys from software.

The cheapest mistake right now is to ship beautiful human interfaces and hope agents will cope. They won’t.

The expensive mistake is to let emergent, fully permeable agent markets couple tightly to your human systems without proofs, auctions, or routing. They’ll be fast, until the day they aren’t.

The opportunity is to design the sandbox. Publish manifests. Auction scarce resources with fairness in mind. Route cognition like a utility. Pay contributors via verifiable credit. Set permeability per risk class. Aim markets at missions. And do the whole thing with security inside the conversation, not a wrapper on the outside.

I’ll leave you with a question that should guide your next quarter:

If an autonomous buyer landed on your product today, could it evaluate you, verify you, and transact safely—without a human in the loop—and would you be proud of what it optimizes for?

If the answer is anything but an unambiguous yes, you just found your roadmap.