For the last couple of years, I’ve been sitting at the intersection of blockchain and AI. And there’s an idea I can’t shake:

Blockchain was a precursor. Infrastructure that enables AI systems to function as economic actors.

I’m not entirely sure how to fully articulate it yet. But one example makes it concrete: stablecoins. They’re the first form of internet-native money, which makes them the first form of money AI agents can actually use.

This thought has been stuck in my head. So I’ve decided to explore it. Pact is where that exploration begins.

What is Pact?

Pact is a minimal primitive for structuring agreements that require judgment to evaluate.

That sounds abstract, so let me break it down.

Smart contracts are great at deterministic conditions. “If X happens, release Y.” The logic is computable, the outcome is binary, and no interpretation is needed.

But most real agreements aren’t like that.

  • “Deliver quality work”
  • “Complete the feature to spec”
  • “Act in good faith”

These require judgment. Someone (or something) has to look at what was delivered and decide, “was this good enough?”

That’s what Pact is for. It’s a schema for encoding commitments in a way that external resolvers (human, AI, or hybrid) can evaluate. Not a replacement for smart contracts. A complement. For everything smart contracts can’t handle.

Why does this matter?

If AI agents are going to transact, collaborate, and coordinate, they need more than money. They need trust infrastructure.

Think about what happens when an AI agent hires another agent (or a human) to complete a task:

  1. They need to agree on terms
  2. Funds need to be held in escrow
  3. Work needs to be delivered
  4. Someone needs to verify the work was done
  5. Payment needs to be released (or disputed)

Steps 1, 2, and 5 are solvable with existing crypto primitives. But steps 3 and 4 is where things break down.

How does an AI agent verify that “quality work” was delivered? How does it evaluate whether acceptance criteria were met when those criteria involve nuance, context, or interpretation?

You can’t compute your way through ambiguity. So you need arbitration.

That’s the gap Pact tries to fill. Structured commitments with pluggable resolution.

The shape of a pact

A pact isn’t complicated. At its core:

  • Parties: Who’s involved (client, provider, could be humans, agents, or both)
  • Terms: What’s being agreed to, including acceptance criteria
  • Stakes: What’s on the line (escrow, reputation, access)
  • Resolver: Who evaluates fulfillment (AI, human, DAO, oracle)

The acceptance criteria are key. They’re inspired by software development practices. Discrete, observable conditions that define “done.” Clear enough for a machine to evaluate, flexible enough for real-world work.

Here’s what a simple pact looks like:

{
   "pact": {
      "version": "0.2",
      "parties": [
         { "id": "0xClient...", "role": "client" },
         { "id": "0xProvider...", "role": "provider" }
      ],
      "terms": {
         "description": "Design a logo for a podcast",
         "acceptance_criteria": [
            "Delivers 3 distinct concepts",
            "Includes source files",
            "One round of revisions included"
         ]
      },
      "stakes": {
         "type": "escrow",
         "amount": "200",
         "currency": "USDC"
      },
      "resolver": {
         "type": "ai",
         "id": "0xResolver..."
      }
   }
}

Nothing revolutionary in the structure. The key thing is what it enables, machine-readable agreements with external arbitration built in.

AI as arbitrator

This is where it gets interesting.

Traditionally, disputes are resolved by humans. Courts, mediators, customer support. Slow, expensive, doesn’t scale.

But if the terms of an agreement are structured clearly enough, maybe an AI can evaluate them. Okay, not perfectly, but probably well enough. And for low-stakes, high-volume transactions between agents, “well enough” might be exactly what’s needed.

Imagine an AI resolver that:

  • Reads the pact terms and acceptance criteria
  • Reviews the submitted evidence
  • Evaluates each criterion: met or not met
  • Returns a verdict with reasoning and confidence scores

The structure of a Pact is designed to make this possible. Clear criteria, structured evidence, machine-readable schema.

Of course, AI resolution isn’t appropriate for everything. High-stakes disputes still need human judgment. That’s why Pact supports multiple resolver types, AI, human, DAO, oracle, or hybrid. A Pact doesn’t care who resolves. It just defines the interface.

Why I’m building this

I should be clear about what I am and what I’m not.

I’m not a machine learning engineer or an AI researcher. I’m a builder. I’ve spent years working in the blockchain space, most recently on stablecoin infrastructure. I understand how to connect financial primitives to software systems.

What I see is a gap.

AI agents are getting more capable. They can reason, plan, and execute. But they can’t yet participate in economic coordination the way humans do. They can’t enter agreements, build reputation, or resolve disputes.

Stablecoins solved the money problem. Pact is my attempt to solve the agreement problem.

I don’t know if this is the right approach. The spec might be wrong. The abstractions might be off. But I think the direction is right: AI agents need trust infrastructure, and that infrastructure needs to be open, composable, and machine-native.

What comes next

Pact is just the beginning.

Over the next few posts and experiments, I’ll be building things that expand on this idea. Testing the spec. Building tooling. Seeing what breaks.

Some questions I’m exploring:

  • How do agents discover each other and negotiate terms?
  • What does reputation look like when it’s portable across contexts?
  • How do you bootstrap trust in a system where any party might be a machine?
  • What happens when agents can enter agreements, escrow funds, and resolve disputes, all without human intervention?

I don’t have answers yet. But I have a direction.

If you’re interested in following along, the spec is live at pact-spec and the repo is on GitHub.

And if you have thoughts, critiques, or ideas I’d genuinely like to hear them.

Let’s see where it goes.