The next scarce resource isn't intelligence. It's agent decisions.
I've been thinking about something that's been bothering me lately.
For the last few years, almost every conversation about AI has centered on intelligence. Which model is smarter? Which one reasons better? Which one writes better code?
Those are important questions. But I don't think they're the ones that will matter most over the next decade.
I think the more interesting question is: how do intelligent systems make decisions?
Over the last decade, we optimized for human attention.
Feeds, notifications, search rankings, recommendation systems, and ad auctions all competed for the same scarce resource: where a person looked next.
As AI agents become more capable, I think that scarce resource begins to shift.
Instead of competing for human attention, we'll increasingly compete for agent decisions.
Imagine an agent managing parts of your digital life. It books travel, pays invoices, sends emails, writes code, manages infrastructure, and buys software.
Every few seconds it's making decisions like:
- Which API should I call?
- Which payment provider should I use?
- Which search engine should I trust?
- Which model should I route this request to?
- Which MCP server has the information I need?
- Which human should I ask for approval?
Most of those decisions are hidden today. They're buried inside prompts, hardcoded into tool lists, or wired together with custom logic.
I don't think they'll stay hidden for long.
As agents become more autonomous, these decisions become the product.
The services agents choose will receive more traffic. The ones they stop trusting won't. Routing, switching, escalation, and coordination become new forms of competition—just as attention became the defining battleground of the consumer internet.
That realization made me step back and ask a bigger question.
How should intelligent systems make these decisions in the first place?
Right now, most of the industry is focused on building better pieces of the puzzle.
Better models.
Better tools.
Better agents.
That's exactly what should be happening.
But I think there's another layer that's still largely unexplored.
What happens when millions—or eventually billions—of intelligent systems interact with one another?
How do they decide who to trust?
When do they stop relying on a service that's becoming unreliable?
How much should latency matter compared to incorrect answers?
Should an agent trust its own experience, or listen to recommendations from other agents?
How do these behaviors shape entire ecosystems?
Those questions feel less like machine learning and more like economics, behavioral science, or distributed systems. They're about how intelligent systems behave collectively, not just how capable an individual model is.
Over the past few months, I've been exploring a different problem: how to safely constrain AI systems before they take actions.
The first three Tether experiments focused on supervision and enforcement. The question was simple:
Can we put deterministic guardrails around probabilistic agents?
That work taught me a lot, but it also exposed another question.
Even if an agent is safe to act, how does it decide what action to take?
In Experiment 1, unsupervised agents failed stochastically. In Experiment 2, supervision cut leak rates but left residual risk. In Experiment 3, enforcement made the remaining risk operationally expensive — about 1 in 6 supervised sends needed intervention.
Useful work. Still narrow. It studied whether an action should proceed.
It did not study which dependency an agent should choose when several are available — or when a preferred one starts to fail.
In production, agents don't just generate text. They choose tools, vendors, services, knowledge sources, workflows, and people.
Those decisions compound over time.
A small preference repeated millions of times can reshape markets.
That's the research direction I want to explore next.
I'm interested in understanding how intelligent systems form preferences, build trust, coordinate with one another, and adapt as their environment changes.
Rather than arguing about these questions in the abstract, I'd rather build simulation environments and see what actually happens.
The first project is intentionally small.
Intelligent Systems Simulator v0
The first question I'm asking is surprisingly simple:
At what point does an agent stop trusting a service and choose an alternative?
My initial guesses are:
- Repeated failures matter differently than isolated ones.
- Latency influences decisions differently than incorrect answers.
- Reputation from other agents changes behavior.
- Different models develop different trust dynamics.
Maybe all of those assumptions are wrong.
That's exactly why I want to build the simulator.
My hope is that this grows into something much bigger than a single experiment.
I'd like to build open simulations, benchmarks, and eventually a deeper understanding of how societies of intelligent systems behave—not just individually, but collectively.
If products emerge from that work, great.
But I don't want to start with a product thesis and work backwards.
I'd rather start with a question that's worth answering and let the evidence lead from there.
I'll be publishing the simulator, experiments, failures, and findings publicly as I go.
If you're building agentic products and you've seen an agent make a surprisingly good—or surprisingly bad—decision about which tool, service, or person to rely on, I'd love to hear about it.
Those stories are exactly the kind of data that inspired this project in the first place.