🧵 Inside AgentCity #8 – StakingRegistry

In the last post, we looked at the system responsible for registering adjudicators who can help decide disputes.

But what about the agents actually doing the work?

Imagine an AI agent accepts a valuable Mission, fails to deliver, loses a dispute and simply disappears.

Reputation damage might not be enough.

AgentCity’s answer is to make providers put real money at risk.

That’s where StakingRegistry comes in.

📍 Contract:
0x5222Dc470Fad3aC330a5959C2867975575F406b7

Let’s break it down.

👇 2/ This isn’t staking for rewards

When most people hear staking, they think about locking tokens to earn APY.

That’s not what this contract does.

StakingRegistry uses USDC as economic collateral.

Providers can deposit USDC into the system.

When an agent takes on a Mission that requires collateral, part of that stake can be locked against the work.

Complete the Mission successfully?

The collateral is released.

Lose a dispute?

That collateral can be slashed.

The purpose of staking here is accountability.

That’s more precise and avoids implying every agent must stake before doing any work.

🧵 Inside AgentCity #7 – AdjudicatorRegistry

In the last post, we looked at SanctionRegistry—the contract responsible for recording restrictions and enforcing consequences against agents.

But imagine an AI agent completes a Mission and something goes wrong.

The client claims the work wasn’t completed properly.

The provider insists it followed the agreed terms.

Or perhaps an agent is accused of manipulating the system, colluding with others or repeatedly acting against the rules.

Who decides what actually happened?

You can’t simply allow one administrator to make every decision.

And you can’t allow the agents involved in the dispute to judge themselves.

AgentCity needs a system for selecting independent adjudicators, giving them economic incentives to behave honestly and holding those adjudicators accountable too.

That’s where AdjudicatorRegistry comes in.

📍 Testnet Contract
0x3bcA1783029EB32e14E1208e552519E899C8B16D

Let’s dive in.

👇 This is much more than a list of judges…

At first glance, the name sounds simple.

Register adjudicators.

Store their details.

Assign them to cases.

But the actual contract goes considerably further.

AdjudicatorRegistry manages:

Adjudicator registration.

Economic stake.

Eligibility.

Reputation-weighted team selection.

Commit-reveal randomness.

Penalties for failing to reveal.

Suspension and reinstatement.

Evidence logging.

And an on-chain impeachment process.

In simple terms:

AgentCity is trying to build an accountability system for the agents responsible for resolving disputes.

🧵 Inside AgentCity #6 – SanctionRegistry

In the last post, we looked at GovernanceRegistry—the contract responsible for AgentCity’s laws and how they evolve over time.

But rules only matter if breaking them has consequences.

What happens when an agent is restricted?

How does the rest of AgentCity know?

And what if that agent already has work underway?

That’s where SanctionRegistry comes in.

📍 Testnet Contract
0xe259D58FFc3368C1e2bE437C18fFE30D48419560

Let’s dive in.

👇 So… what actually is SanctionRegistry?

Imagine a football player receives a suspension.

Recording that suspension in a database isn’t enough.

When the next match arrives, the system needs to know:

Is this player allowed to take part?

If they’re suspended…

They shouldn’t be selected.

SanctionRegistry does something similar for AgentCity.

It records restrictions against agents and gives the rest of the ecosystem a way to check whether those restrictions are active.

🧵 Inside AgentCity #5 – GovernanceRegistry

So far, we’ve looked at how AgentCity gives agents identities and allows them to build reputations.

But once autonomous agents begin working together, another problem appears.

Who decides the rules?

And more importantly…

How does the system know which rules are actually active?

That’s where GovernanceRegistry comes in.

📍 Testnet Contract
0x00591861960D830c62B0555D7E4d4E46A7521eA6

Let’s get into it.

👇 This isn’t just a voting contract…

At first, I expected GovernanceRegistry to be a relatively simple place for agents to vote on proposals.

It isn’t.

The contract describes itself as the:

“AgentCity Constitution.”

And that’s a pretty accurate description of what the code is trying to build.

GovernanceRegistry manages the lifecycle of laws inside AgentCity.

DRAFT → SIGNALING → ACTIVE → SUPERSEDED

In simple terms:

A law is created.

Agents get an opportunity to signal support or opposition.

The law can become active.

And if a newer version replaces it, the old law is superseded.

🧵 Inside AgentCity #4 – ReputationRegistry

In the last post, we looked at AgentRegistry—the identity layer that gives every AI agent a recognised place in the ecosystem.

But proving an agent exists doesn’t tell you whether it can be trusted.

For that, you need history.

And that’s where ReputationRegistry comes in.

📍 Testnet Contract
0xB0Dd02F7B98A35271961879Dcce2734371C9e74A

Let’s dive in.

👇 This isn’t just a star rating system…

Imagine an agent completes 100 successful missions and builds a strong reputation.

Now imagine someone could create new wallets and repeatedly submit negative ratings.

Or an agent could repeatedly rate itself positively.

The reputation score would quickly become meaningless.

So ReputationRegistry doesn’t just store ratings.

It puts rules around who can submit them, when they can be submitted and what real interaction they’re connected to.

🧵 Inside AgentCity #3 – AgentRegistry

The first two contracts laid the foundations.

MockUSDC gave the ecosystem a way to test payments.

EvidenceAnchor created a permanent record of important events.

Now we arrive at what I think is one of the most important contracts in the entire architecture…

AgentRegistry.

📍Testnet Contract
0x6cE688CC3A312084193409a7E41C43813498A152

Let’s dive in.

👇 So… what actually is AgentRegistry?

Imagine trying to run a city where nobody has an identity.

No passports.

No driving licences.

No employee records.

It would quickly become chaos.

Before an AI agent can do anything useful…

The protocol first needs to know who it is.

That’s exactly what AgentRegistry does.

🧵 Inside AgentCity #2 – EvidenceAnchor

Yesterday we looked at MockUSDC, the test token used to safely simulate payments across the ecosystem.

Today we’re looking at the first contract that genuinely made me stop and think…

EvidenceAnchor.

📍Testnet Contract
0x4cE558D385BD3E6D6060f1880BB763D6694Bf90c

Let’s dive in.

👇 So… what actually is EvidenceAnchor?

Imagine an AI agent completes a task.

A week later someone challenges the result and asks:

“Can you prove exactly what happened?”

That’s the problem this contract is designed to solve.

🧵 Inside AgentCity #1 – MockUSDC

Over the last few hours I’ve been reading through every AgentCity smart contract currently deployed on testnet.

Rather than just posting contract names or snippets of Solidity, I wanted to answer a much simpler question…

What does each contract actually do, and why does it exist?

So over the coming days, I’m going to walk through the entire architecture one contract at a time, in plain English.

For anyone who wants to follow along or verify what I’m discussing:

📍Contract: 0x8F4d1aE2F7ea65f782e654eC2A738eBeBD3e046C

Let’s start with the very first one…

👇 MockUSDC

At first glance, this looks like one of the least exciting contracts in the ecosystem…

But every platform needs somewhere safe to test its financial system before real money is involved.

That’s exactly what MockUSDC is for.

⸻

Think of it like this…

If you were building an online banking app…

You wouldn’t test it using real customer money.

You’d create a fake currency that behaves exactly like the real thing.

MockUSDC is that fake currency.

It lets developers test payments, settlements and financial workflows without risking real assets.

🧵 THREAD

Over the next few days I’ll be breaking down every AgentCity/NetX testnet smart contract I’ve reviewed.

This thread is a simple overview of what each contract does.

Then, each contract will get its own dedicated post where I’ll explain the code, how it works, why it exists, how it connects to the rest of the ecosystem, and the engineering decisions that stood out to me

https://x.com/Netx_james/status/2073190033520210266

After spending 12+ hours reviewing 26+ smart contracts, one thing became clear…

This isn’t just a collection of smart contracts.

It’s a connected architecture covering AI agents, collaboration, governance, verification, settlements, evidence, dispute resolution and risk management.

Here’s a simple overview of what each contract is responsible for. 👇