u/AgentNOMOS

For the last few months I've been working on a problem that I think becomes important once AI agents can actually spend money and execute consequential actions:

Capability is not authority. And payment is not proof of execution.

So I built AgentNOMOS around a chain that binds things like:

intent → capability → offer → security evidence → authorization → execution → signed receipt → outcome

We've tested the path ourselves.

That's no longer the interesting part.

The question I actually want answered is:

Can an agent that I don't control discover the public interface, figure out how to invoke it, complete the paid flow, receive the execution receipt, and verify that receipt itself?

So I published a small public challenge.

The only technical starting point is the public Agent Card.

No prepared curl command.
No POST payload.
No private endpoint.
No NOMOS credentials.

The actual call costs $0.001 USDC on Base via x402.

If your agent completes it, I'm interested in the transaction hash / receipt ID and verifier result so I can distinguish a real external traversal from my own internal testing.

I'm deliberately separating:

• discovery-first external traversal
• assisted external traversal
• our own internal tests

because I don't want to call something "external" if it isn't.

Challenge:

https://agentnomos.com/challenge/

I'm especially interested in what breaks.

If your agent gets stuck at discovery, schema resolution, x402, execution, receipt handling or verification, that is useful information too.

Please use only the documented public interfaces. This isn't a security-bounty invitation or a request to probe private infrastructure.

>Yesterday we finished something I’ve been working toward for quite a while: making an agent transaction trust chain machine-discoverable rather than something that only exists in architecture diagrams.

The capability is called nomos_full_chain_verification.

The basic idea is that an agent action should not end at:

discover → pay → execute

We bind:

intent → capability → offer → security evidence → authorization → execution → signed receipt → outcome

The receipt can then be verified separately.

But after publishing it, the question I was actually interested in was much simpler:

Will another machine find it without us guiding it?

So we did nothing.

No outreach to a specific buyer.
No test invocation.
No additional canary.
No payment from us.

We just watched the production telemetry read-only.

Within hours, two independent Node clients did this:

/.well-known/x402

↓

discovered the newly published capability

↓

POST /v2/nomos_full_chain_verification

↓

received the correct HTTP 402 payment challenge

↓

stopped

Neither client paid, so this is not a customer story and I don’t want to present it as one.

But for me the interesting part is that discovery actually worked outside our own environment.

Another external actor followed an even deeper inspection path:

Agent Card
→ AI Catalog
→ llms.txt
→ full-chain capability
→ capabilities
→ reproducibility bundle
→ proof material

Again: no claim about who that actor was or why they did it.

What I find interesting is the behavior itself.

We spend a lot of time talking about agent interoperability as a future problem. But once agents can discover capabilities, payment requirements and verification material themselves, the interface starts behaving less like a website and more like infrastructure intended for machines.

The next boundary is now obvious:

discovery → invocation → 402 → ?

We’ve seen external machines reach the payment boundary.

What I want to find out next is whether an unrelated external agent will eventually complete the entire path on its own:

discovery
→ payment
→ authorization
→ execution
→ signed receipt
→ verifiable outcome

If that happens, that will be much more interesting to me than the payment itself.

Because the real question isn’t whether an AI agent can pay an API anymore.

It’s whether trust can survive the entire transaction.

Curious how others building agent infrastructure think about this:

Where should the trust boundary end — at payment authorization, execution, or the resulting outcome?

’ve been working on this problem for a while and finally tried to put the architecture into one picture.

The basic idea is simple:

Capability is not authority.

An agent may technically be able to discover a service, negotiate, call an API or prepare a payment. That doesn’t automatically mean it should be allowed to execute it.

So I’m building NOMOS around a trust chain:

Discover → Verify → Authorize → Execute → Prove → Observe → Govern

The part I care about most is what happens between intent and execution.

Before an agent performs an irreversible action, the system can ask things like:

Is the identity known?
Is the information still fresh?
Does this agent actually have authority?
Does the action match the original intent?
Does policy allow it?
What evidence supports that decision?

And after execution, the result should feed back into future trust rather than disappearing into a log.

That’s why the longer chain in the image goes from freshness and identity all the way through execution, proof, reliability and governance.

I’m not claiming this is the only correct architecture. I’m actually interested in where other builders disagree with it.

If you were putting a governance layer in front of an autonomous wallet or agent, which part of this chain would you remove — and what is missing?

That’s the feedback I’m looking for.

https://preview.redd.it/hjirhh780xhh1.png?width=1254&format=png&auto=webp&s=49ca4d353bda434f7fc11e0c3131e633e06f1a5d

I’m building AgentNOMOS, and I would like feedback from people working on

AI agents, wallets, x402 or XRPL infrastructure.

The problem we are trying to solve:

An autonomous agent prepares a payment, but before it signs the transaction,

someone should verify:

- Is the agent authorized to make this payment?

- Is the destination allowed?

- Does the amount match the original intent?

- Does the action require human review?

- Can the decision later be proven?

Our current flow is:

1. The agent prepares a payment intent.

2. It calls AgentNOMOS before signing.

3. It pays 0.001 XRP through x402 for the preflight.

4. AgentNOMOS returns a governed decision and transaction-bound evidence.

5. The agent signs only if the result allows it.

The transaction being evaluated does not need to exist on-chain yet.

The 0.001 XRP transaction pays for the preflight itself.

We now have two live XRPL Mainnet services:

- Governed XRPL Payment Preflight

- Cross-Border Compliance Preflight

Both are listed in the XRPL x402 marketplace and have completed real

Mainnet canaries.

But we are at the stage where external usage matters more than adding more

endpoints. Our current external-user baseline for these two services is

honestly zero.

So I have three questions for builders:

1. Would a separate 0.001 XRP payment for every preflight be acceptable?

2. Would payment channels, prepaid credits or batched settlement make more sense?

3. What would AgentNOMOS need to return before you would place it in front of

   a real wallet, treasury or trading agent?

The live integration examples and Mainnet proofs are here:

https://agentnomos.com/xrpl

I’m looking for criticism and one or two real integrations, not artificial

transaction volume.

I’m building AgentNOMOS, and I would like feedback from people working on

AI agents, wallets, x402 or XRPL infrastructure.

The problem we are trying to solve:

An autonomous agent prepares a payment, but before it signs the transaction,

someone should verify:

- Is the agent authorized to make this payment?

- Is the destination allowed?

- Does the amount match the original intent?

- Does the action require human review?

- Can the decision later be proven?

Our current flow is:

1. The agent prepares a payment intent.

2. It calls AgentNOMOS before signing.

3. It pays 0.001 XRP through x402 for the preflight.

4. AgentNOMOS returns a governed decision and transaction-bound evidence.

5. The agent signs only if the result allows it.

The transaction being evaluated does not need to exist on-chain yet.

The 0.001 XRP transaction pays for the preflight itself.

We now have two live XRPL Mainnet services:

- Governed XRPL Payment Preflight

- Cross-Border Compliance Preflight

Both are listed in the XRPL x402 marketplace and have completed real

Mainnet canaries.

But we are at the stage where external usage matters more than adding more

endpoints. Our current external-user baseline for these two services is

honestly zero.

So I have three questions for builders:

1. Would a separate 0.001 XRP payment for every preflight be acceptable?

2. Would payment channels, prepaid credits or batched settlement make more sense?

3. What would AgentNOMOS need to return before you would place it in front of

   a real wallet, treasury or trading agent?

The live integration examples and Mainnet proofs are here:

https://agentnomos.com/xrpl

I’m looking for criticism and one or two real integrations, not artificial

transaction volume.

I’ve been building infrastructure where AI agents can discover tools, pay for them and receive verifiable evidence about what happened.

Recently, an external wallet completed 12 successful payments across more than 11 API routes.

Total revenue: $0.31.

Obviously, that amount changes nothing financially.

But it proved something important: autonomous payment already works.

The real bottleneck is trust.

Before I would let an agent spend meaningful money, I would want clear answers to questions like:

• Who actually operates the tool?
• What is the exact price before execution?
• What data will leave the system?
• Can the result be independently verified?
• What happens when a policy or risk check fails?
• Is there a signed record of the decision and payment?

We started treating every tool call as a small decision record:

identity → policy → risk → evidence → payment → result

The payment part turned out to be easier than proving that the action should have happened.

Context: I’m building this infrastructure myself, so I’m obviously biased. I’m not adding a product link because I’m more interested in the engineering question:

What would you require before allowing an AI agent to spend money autonomously?

Budget caps? Allowlisted providers? Simulation first? Signed receipts? Human approval? All of them?

I’ve been building infrastructure where AI agents can discover tools, pay for them and receive verifiable evidence about what happened.

Recently, an external wallet completed 12 successful payments across more than 11 API routes.

Total revenue: $0.31.

Obviously, that amount changes nothing financially.

But it proved something important: autonomous payment already works.

The real bottleneck is trust.

Before I would let an agent spend meaningful money, I would want clear answers to questions like:

• Who actually operates the tool?
• What is the exact price before execution?
• What data will leave the system?
• Can the result be independently verified?
• What happens when a policy or risk check fails?
• Is there a signed record of the decision and payment?

We started treating every tool call as a small decision record:

identity → policy → risk → evidence → payment → result

The payment part turned out to be easier than proving that the action should have happened.

Context: I’m building this infrastructure myself, so I’m obviously biased. I’m not adding a product link because I’m more interested in the engineering question:

What would you require before allowing an AI agent to spend money autonomously?

Budget caps? Allowlisted providers? Simulation first? Signed receipts? Human approval? All of them?

NOMOS ist die Governance- und Evidence-Infrastruktur für maschinenzahlende AI-Agenten. Es prüft Identität, Regeln, Risiko, Berechtigung und Evidenz vor einer Aktion und erzeugt danach überprüfbare Receipts.

#AI #aiagent