---
title: Empirical Game Theory for Agents
date: 2026-05-08
slug: empirical-games-and-algorithmic-game-theory-for-agents
summary: Empirical game-theoretic analysis is one of the best ways to study how agent policies actually interact, while algorithmic game theory gives the language for designing those interactions on purpose.
tags: game-theory, egta, agents
---

I think one of the biggest missed opportunities in current agent evaluation is the lack of serious **empirical game-theoretic analysis**.

Most evaluations still look like isolated benchmark scores: one agent, one task, one result. That is useful, but it misses the part that becomes economically important as soon as agents coexist: **strategic interaction**.

What happens when multiple routing policies compete in the same environment? What happens when some agents specialize, others imitate, and others bid aggressively? What happens when the system rewards early completion in a way that encourages lower-quality work?

Those are game-theoretic questions, and empirical methods matter because the systems are too messy to understand from first principles alone.

## Why empirical game-theoretic analysis fits agentic systems so well

The core idea of empirical game-theoretic analysis is simple: instead of assuming the payoff matrix analytically, you estimate it from simulations or measured interactions across strategy profiles.

That is incredibly natural for agentic systems.

You can define a profile as a combination of policies:

- routing policy,
- bidding policy,
- retry policy,
- review policy,
- settlement rule,
- memory-sharing rule.

Then you simulate or replay many runs, observe payoffs, and build an empirical game from the results. That does not magically solve everything, but it gives you a disciplined way to ask whether a policy is robust, exploitable, or equilibrium-seeking.

In practice, the loop looks something like this:

```go
package egta

type Profile struct {
	Router   string
	Bidder   string
	Reviewer string
}

type Outcome struct {
	Utility float64
	Cost    float64
	Success float64
}

func Payoff(o Outcome) float64 {
	// Collapse the observed outcome into one comparison-friendly payoff.
	return o.Utility - o.Cost + o.Success
}
```

The hard part is not writing the struct. The hard part is running enough controlled interactions that the estimated game tells you something real.

## Algorithmic game theory gives the design language

Empirical analysis tells you what the interaction landscape looks like. Algorithmic game theory helps you design mechanisms inside that landscape.

This is why I see the two fields as complementary rather than separate. If empirical analysis shows that a bidding policy drives destructive races to the bottom, algorithmic game theory gives you tools to redesign the allocation rule. If the system converges to low-quality equilibria, you can adjust incentives, information disclosure, reserve prices, or admission rules.

That is much better than pretending the benchmark failed because the model was “not smart enough.”

Often the issue is not intelligence at all. It is the game.

## This matters because agent evaluation is becoming multi-agent evaluation

As soon as agents operate in shared repos, shared queues, or shared markets, single-agent accuracy stops being the whole story.

You need to ask:

1. whether a strategy is stable against exploitation,
2. whether incentives improve or degrade quality,
3. whether the system produces concentration or diversity,
4. whether local gains create bad global equilibria.

Those questions belong naturally to empirical game-theoretic analysis.

I expect this to matter even more in agent marketplaces, decentralized software work, autonomous procurement, and negotiation-heavy systems. In all of those settings, the interaction surface is the product.

## The books I would put on this shelf

[![Twenty Lectures on Algorithmic Game Theory cover](https://assets.cambridge.org/97811071/72661/cover/9781107172661.jpg)](https://www.cambridge.org/9781107172661)

Tim Roughgarden's *Twenty Lectures on Algorithmic Game Theory* is an excellent compact map of the field because it keeps the link between computation and incentives visible. That is exactly the connection agent builders need.

[![Multiagent Systems cover](https://assets.cambridge.org/97805218/99437/cover/9780521899437.jpg)](https://www.cambridge.org/9780521899437)

*Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations* matters because it frames strategic interaction as a systems problem, not just an economics problem. That viewpoint feels especially relevant for agentic software engineering.

## My practical reflection

I think teams building serious agent systems should evaluate at least some policy decisions as empirical games. Not every product needs a giant formal mechanism. But once many agents can adapt to each other, benchmark culture by itself becomes too shallow.

Empirical game-theoretic analysis gives you a way to measure interaction. Algorithmic game theory gives you a way to redesign it. Together they make agentic systems easier to reason about, especially when the failure mode is not a crash or a bug, but a bad equilibrium.

That is a much more interesting class of engineering problem than most AI dashboards currently expose.

## Sources

- [Twenty Lectures on Algorithmic Game Theory](https://www.cambridge.org/9781107172661)
- [Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations](https://www.cambridge.org/9780521899437)


This is engineering at the systems level: choosing the right tool for the constraint. The constraint determines the architecture. The architecture determines the language choice. The language choice determines the ecosystem. The chain of dependencies runs from the resource budget (compute, memory, latency) through the system design to the implementation language. The engineer who traces the chain makes principled choices. The engineer who doesn't inherits choices made by others for different constraints.


> Game theory is not about predicting what people will do. It is about understanding the structure of their choices. The structure is the game. The game is the constraint.