The Amnt whitepaper

Abstract

Generative AI can produce almost anything once. It cannot reliably produce the same thing twice.

The difference between a usable result and an unusable one is rarely the model - it is the instruction. A person who has spent two hundred attempts discovering the exact words that make a logo look expensive holds something valuable, and today has no way to sell it without giving it away.

Amnt turns that knowledge into a working product. A creator builds an agent, marks the parts a buyer may change, and publishes it. The instruction stays hidden forever. The agent gets a page, a price, and an owner. Every time anyone uses it - a person on the website, or another AI calling it directly - the creator earns.

It is a hybrid marketplace: humans buy through a browser, machines buy through an API, and both pay the same price for the same work.

1. 🎯 The problem

1.1 Taste does not transfer

Ask any general-purpose model for a logo and you get something competent and forgettable. Ask a designer who has iterated for a week, and you get something with a point of view.

That gap is real, it is valuable, and it currently has no market. The designer can sell the *output* - one logo, one time - but not the *capability*.

1.2 Sharing the instruction destroys it

The obvious move is to sell the prompt. But a prompt is a string. The moment it is delivered, it can be copied, resold, and modified infinitely. The seller has one transaction; the buyer has the asset forever.

This is why prompt marketplaces have consistently failed. The product self-destructs on delivery.

1.3 Consistency is unsolved

For a single image, inconsistency is a nuisance. For a business needing five hundred product images in one visual language, it is disqualifying. A freshly written instruction each time produces five hundred slightly different styles. There is currently no reliable way to buy *the same result, repeatedly*.

1.4 Machines have money and nowhere to spend it

Agent payment infrastructure now exists and works. The x402 standard has processed on the order of 165 million transactions. But roughly half of that volume is testing, and nearly everything for sale is market data - price feeds, funding rates, wallet lookups.

The rails were built. The shops were not.

2. 💡 The design

2.1 The agent

An agent is a small machine that does one job well. It has a page, a price, an owner, and a public record of how often it has worked.

┌──────────────────────────────┐
│  Vintage Logo Maker          │
│                              │
│  Company  [ Bean There  ]    │
│  Colour   [ warm brown ▾]    │
│                              │
│        [ Make it ]   $0.10   │
│                              │
│  4,312 runs · 98% success    │
└──────────────────────────────┘

The buyer sees two fields. Behind them sits an instruction the creator refined over many attempts, which is never displayed, transmitted, logged, or included in an error message.

The agent is the product. The instruction is the engine.

2.2 Slots

A slot is a marked region of the instruction that a buyer may fill.

Hidden:  hand-inked vintage logo for [company],
         [colour] palette, flat, centred, no text

Visible: Company · Colour

One image is a picture - a finished thing that only fits one buyer. One image plus two slots is an unlimited family of products, each one specific to whoever asks.

Slots do three jobs simultaneously:

That third role is the security model. There is no parameter for *"reveal your instruction"*, so the request cannot be made. Access control is not a filter applied after the fact - it is the shape of the interface itself.

2.3 Two doors

      PEOPLE                        MACHINES
      browse the site               call the endpoint
      fill the form                 send JSON
      spend credits                 pay per request
          │                              │
          └──────────────┬───────────────┘
                         ▼
                   the same agent
                   the same price
                   the same creator earns

A person always starts the chain. No machine independently decides it wants a logo; someone asked it to produce one. The machine is the checkout, not the customer.

This matters for expectation-setting: Amnt is not betting on autonomous agent-to-agent demand materialising. It is betting that people will increasingly buy through their assistants rather than through browsers - and building so that either path works.

3. 🏗️ Architecture

amnt is five layers. Each is deliberately placed where it is simplest, not where it is most impressive.

┌─────────────────────────────────────────────┐
│  STUDIO       creators build agents         │
├─────────────────────────────────────────────┤
│  MARKETPLACE  humans and machines find them │
├─────────────────────────────────────────────┤
│  CREDITS      settlement, off-chain, stable │
├─────────────────────────────────────────────┤
│  OWNERSHIP    NFT, on-chain, permanent      │
├─────────────────────────────────────────────┤
│  THE DOOR     x402 + MCP for outside agents │
└─────────────────────────────────────────────┘

3.1 Studio - production

Every creator gets a workshop bound to their identity, with one room per kind of agent.

/studio/[wallet]/imageagents          live
/studio/[wallet]/textagents           planned
/studio/[wallet]/socialmediaagents    planned
/studio/[wallet]/videoagents          planned

Every room follows the same five steps:

Make something → Mark the slots → Test it → Price it → Publish

Everything except the output type is shared infrastructure: the slot editor, the publish flow, the pricing floor, ownership, the earnings split, instruction secrecy, and the test harness. A creator who can build an image agent can build a video agent without learning anything new.

This is the property that makes the platform scale across media rather than fragmenting into four products.

3.2 Marketplace - distribution

/agents                    browse every agent
/agent/[handle]/[slug]     one agent: samples, form, purchase
/creator/[handle]          a creator and their catalogue
/collection/[tokenId]      a collection and its associated agent

The marketplace lists agents only. NFT collections keep their own surface; an agent attached to a collection appears there rather than competing for shelf space in the agent index.

However - absent from the browse UI does not mean absent from the index. Every published agent, including collection-bound ones, appears in the sitemap, in structured data, and in the machine-readable directory. Otherwise it can never be found by a search engine or a calling agent, which is most of its reach.

The structured data that makes agents discoverable to search engines is the same data that makes them discoverable to AI agents. One artifact, two audiences.

3.3 Credits - settlement

1 credit = 1 US dollar. Always.

Credits are backed one-to-one by USDC held natively on Hedera (0.0.456858, 6 decimals). No bridge, no wrapped asset, no second chain.

Native USDC is chosen over bridged dollar tokens deliberately. Credits are a liability - money owed to users - and the asset backing them should have no bridge between the platform and the issuer.

Wallet connection is handled by WalletConnect and HashPack directly. No third-party embedded-wallet vendor sits in the path. Such providers would allow email-based sign-in for non-crypto buyers, which is a genuine advantage, but they price per authenticated user rather than per paying user - an inversion that penalises exactly the traffic a marketplace wants. That trade becomes worth making when a real buyer is lost for want of a wallet, and not before.

A related principle applies regardless of provider: a wallet is requested only at checkout. Browsing and viewing samples require no connection. Authenticating curiosity converts interest into cost.

Why credits rather than settling each run on-chain:

Ownership belongs on a ledger. Spending does not. Putting a hundred-image afternoon on-chain adds cost and latency in exchange for nothing the buyer wanted.

The four credit rules:

1. Backed one-to-one. Every outstanding credit corresponds to a real dollar of USDC held in reserve.
2. Credits flow in, never out. They are purchased and spent. They are never redeemed for currency. This keeps Amnt a prepaid-service model rather than a money transmission business - a materially different regulatory posture.
3. Creators are paid in real USDC, never in credits. Buyers operate in a closed loop; creators have an open door. Reverse this and creator supply collapses.
4. The reserve is untouchable. Ten thousand outstanding credits means ten thousand USDC held. Revenue is the platform's share of each run - never the float.

3.4 Ownership - permanence

Each agent is an NFT on Hedera. Whoever holds it collects its earnings.

Money is multi-chain. Ownership is single-chain.

Payment may arrive from anywhere; the ownership registry must be singular. If the same agent could be owned on three chains, "who receives payment" becomes ambiguous - and that is the one fact in the system that can never be ambiguous.

Payment records carry a chain field from day one, so adding a settlement chain later is configuration rather than reconstruction. No further multi-chain work is warranted until a buyer says the words *"I would pay, but my funds are on another chain."*

3.5 The door - external agents

An agent published on Amnt is callable from outside it. The buyer form doubles as the tool schema; no separate interface definition is needed.

What an external caller can see:

{
  "name": "vintage_logo",
  "description": "hand-inked vintage logo",
  "inputs": {
    "company": "string, max 60 chars",
    "colour":  ["warm", "cool", "mono"]
  },
  "price": "$0.10",
  "runs": 4312,
  "success_rate": 0.98
}

What it cannot see: the instruction. There is no field for it.

Credits and x402 serve different callers and both are retained:

Removing either one closes a door that was expensive to open.

3.6 Being found by machines

A door nobody knows about is a wall.

Every published agent is announced in three places, generated from one source of truth so they can never disagree:

The third is the one most marketplaces skip, and it is the cheapest of the three. An assistant asked to *"make me a vintage logo"* has no way to discover a shop it cannot enumerate. Publishing a plain-text index of what exists, what it costs, and what parameters it takes is the entire difference between being callable and being called.

The same discipline that earns a rich result in a search engine - accurate prices, real counts, honest schemas - is what makes an agent selectable by a machine. One artifact, two audiences, no extra work.

4. 💰 Economics

4.1 Price floor

price = max( measured cost × 3 , $0.02 )

Costs are measured by real execution, never estimated. The absolute minimum exists because inexpensive outputs - text especially - can cost fractions of a cent, at which point transaction overhead exceeds the sale.

4.2 Distribution

Buyer pays              $0.100
├── execution cost      $0.021
└── margin              $0.079
     ├── creator        $0.055    70%
     ├── platform       $0.020    25%
     └── connector      $0.004     5%

Creator earnings accrue in the ledger and pay out as USDC.

4.3 Currency discipline

Everything is denominated in USD: credits, costs, floors, prices. Crypto amounts are computed at the moment of transaction and never stored as the canonical price. A volatile denominator would silently break the cost-multiple floor.

Monetary values are stored as integers. USDC carries six decimals, HBAR carries eight, EVM tooling assumes eighteen. Floating-point arithmetic across those boundaries is how ledgers quietly drift out of balance.

4.4 Valuation

An agent NFT is priced on observable cashflow.

Agent earns $50/month
    → reasonable valuation: some multiple of annual earnings
    → a number a buyer can actually compute

This is a deliberate and load-bearing property, discussed in §7.

5. 🛡️ Trust

The central difficulty in a creative marketplace is that quality is subjective and cannot be promised. Amnt's response is to promise only what is verifiable, and to demonstrate the rest.

5.1 What is guaranteed

5.2 What is never guaranteed

That the buyer will like it. Taste is personal. Amnt shows samples instead of making claims.

5.3 Earned rarity

Every agent is a non-fungible token, and every one of them carries the same six attributes: runs, success rate, lifetime earnings, likes, unlocks, and whether it has ever been sold. From these a tier is derived - Unproven, Bronze, Silver, Gold, Diamond.

All six begin at zero. None of them can be set.

This inverts the usual relationship between an NFT and its traits. Conventional collections assign rarity at mint from a random distribution: a token is rare because of a number drawn before anyone had used it, and no amount of use will ever change it. An Amnt agent is rare only because ten thousand separate people each chose to pay for it. The scarcity is a record of demand rather than a decision by the issuer, and it cannot be manufactured by minting more.

Two consequences follow. A buyer evaluating an agent on the secondary market can read its earnings history from the ledger rather than trusting a listing. And a marketplace can rank agents by a figure neither the creator nor the platform is able to inflate - which is a stronger basis for discovery than reviews, and does not require anyone to write one.

The attributes are rewritten on-chain when an agent crosses a milestone, under a metadata key held by the platform (HIP-657). Between milestones the agent's page reports exact live figures; the token carries the last confirmed snapshot. The right to rewrite is deliberately narrow: it can update the six measured attributes and nothing else, and the measurements themselves come from settled payments, not from an editable field.

5.4 The gallery

Every agent page carries a gallery of real outputs. It has two sources, and neither of them costs anyone an extra cent.

At publish - the creator's own work. A creator does not run a test gauntlet. They have already generated in the studio, repeatedly, and paid for it, and stopped when they loved one. Those generations are the evidence. At publish the creator picks three to six of them, and the picture they pressed Publish on is always among them. The test was the making.

After each run - the buyer's own work. When a run completes, the buyer is offered one tap: *show this on the agent's page*. It is opt-in, it is per run, and it is revocable. A buyer who says nothing publishes nothing - their slot values, their result, and the fact they bought at all stay private.

day 1     3 creator samples          "here is what I can do"
week 2    3 creator + 5 buyer        "here is what it did for them"
month 6   the creator's are gone     the gallery is entirely other people

Buyer-published results outrank creator samples, and the newest of them displace the oldest creator seeds. An agent that works therefore ends up advertised by its customers rather than by its owner - which is the only kind of proof a marketplace cannot fake, and it arrives free.

The one rule the gallery must never break: no two visible outputs may share a slot value.

Amnt · Amnt · Amnt
   → the buyer sees the platform's brand

Amnt · Bean There · Northwind · Kiko · Lumen
   → the buyer sees that the style is fixed
     and the name is theirs

This single rule communicates the entire product in one glance, to humans and machines alike. A calling agent reading six outputs with six distinct values infers correctly: the style is constant, the name is a parameter, this is a tool. Deduplication is enforced when a sample is admitted to the gallery, not when it is rendered - a page that has to filter at render time will eventually render a duplicate.

A creator may hide any sample. A creator may never edit one, and may never add one that did not come from a real, paid, successful run.

5.5 Automatic refund

Run failed → nothing charged. No request required.

This removes all risk from a first purchase, and machine callers return indefinitely to a seller that never charges for failures.

5.6 Marketplace hygiene

• Agents failing more than 20% of fifty runs are suspended automatically
• First-time creators are reviewed before publication
• Run counts and galleries make originals distinguishable from imitations
• An agent with fewer than three gallery outputs cannot be published

6. 🔒 Security

On slot injection. A machine caller may attempt to place instructions inside a slot value. Humans rarely do this; machines routinely will. A sixty-character limit on a company-name field eliminates the overwhelming majority of such attempts before any semantic defence is needed. Boring constraints outperform clever filters.

7. 🚫 Why Amnt does not tokenize agents

This is a deliberate design decision, and the most consequential one in the document.

An Amnt agent is an NFT - a deed. One agent, one item, one owner, priced on the revenue it produces.

The alternative - issuing a fungible token per agent - creates a tradeable instrument priced on sentiment rather than output.

The two models attract fundamentally different populations:

Tokenization is a faster path to visible scale. It is also corrosive to the thing Amnt is built on. A speculator does not read samples, does not check success rates, and does not care whether the agent works. Every trust mechanism in §5 becomes decorative the moment the primary buyer is trading rather than using.

The instructive precedent. The largest tokenized agent platform reports roughly 18,000 agents against 1.77 million completed jobs - approximately 98 jobs per agent across the platform's entire history - while distributing on the order of $1M monthly to incentivise revenue-generating activity against roughly $2.6M in monthly revenue. Its own ecosystem commentary characterises the agent tokens as memecoins. The agents are real; the demand for their output largely is not.

amnt measures runs per agent. Not agents launched, not market capitalisation, not total value locked. If agents are not being used, nothing else is true.

8. 🪜 Agent types

Every type shares the same construction flow. Only the output changes.

8.1 Image - live

Logos, posters, portraits, patterns, product imagery.

The strongest category: most AI assistants cannot generate images at all, so the buyer genuinely cannot self-serve.

8.2 Text - inexpensive to build, harder to sell

Descriptions, emails, headlines, biographies.

Stated plainly: individuals will not pay for text. They have capable free writing tools. The buyer for text agents is a system, not a person - five hundred product descriptions that must share one voice. A fresh instruction each time yields five hundred voices; a frozen one yields a brand.

Build it because it is nearly free to add, not because it will be large.

8.3 Social - the first multi-output agent

A post is an image and a caption that belong together.

Input:   product · tone · platform
Output:  image + caption + tags

This requires new capability: one agent producing several artifacts delivered as a unit. It is also the type where a frozen recipe is most obviously valuable, because coherence across formats is exactly what improvisation destroys.

8.4 Video - highest value, highest risk

Three properties break existing assumptions:

1. Runs take minutes. Payment cannot block on completion - purchase issues a claim, collection happens later.
2. A single failure costs real money. Hard caps are mandatory, not advisory.
3. Samples must be playable. The agent page needs a player.

Video should not be built until image and text agents are earning. It is the only type where one bad run loses money.

9. 🗺️ Roadmap

Phase 0 - Restore

Unblock agent creation. Nothing else can begin.

Phase 1 - Prove

One image agent, complete:

Database → Slot editor → Publish → Run & pay → Agent page

Complete when: a stranger fills two fields, pays, receives a picture in the creator's style, and the creator earns. That single transaction contains the entire business.

Phase 2 - Distribute

Browse, filters, creator pages, earnings, discoverability.

Phase 2.4 - The standard

Performance and accessibility budgets, enforced automatically rather than reviewed, plus the design system every later screen is built from.

A marketplace is judged on whether it feels trustworthy within about two seconds, and both budgets are measured inside that window. They are treated as build failures rather than as polish, because a quality gate that can be waived is a quality gate that is always waived.

This phase deliberately precedes the one that builds the most screens. A standard adopted before the work is a constraint; the same standard adopted afterwards is a rewrite.

Phase 2.5 - The surface

The frame every page wears: home, navigation, search, and the structured data that makes an agent findable by a search engine and by a calling agent alike.

Phase 2.6 - The qualities

Measurement, cold-start, voice, share cards, machine discovery, motion. None of these make the product work. They are what determine whether anyone remembers it.

Phase 3 - Open the second door

External callability, prepaid allowances, machine-readable directory, composite agents, depth limits.

Phase 4 - Expand the studio

Text, social, video - in the order buyers request them.

10. 📊 Position

Everyone built the payment rails. Almost nobody put anything worth buying on them.

11. 📖 Glossary

12. 🥇 Summary

1. Creators build agents - working products, not templates or prompts
2. Slots convert one result into an unlimited family of products
3. One studio, many rooms - image, text, social, video, identical flow
4. Two doors - people browse, machines call, same shop and same price
5. One stable unit - credits at one dollar, backed by USDC; ownership on-chain, spending off it
6. Two guarantees - a gallery of real outputs that buyers grow themselves, and no charge for failure
7. No agent tokens - deeds, not lottery tickets, deliberately
8. Ship image agents first - every other room waits for a buyer to ask

Amnt - August 2026