DEV Community: Alex

I wanted a signed AIMarket provider without the monorepo. One CLI later, I had one.

Alex — Sat, 22 Aug 2026 05:01:03 +0000

Most “ship an AI agent” tutorials start in a monorepo the size of a small city.

I wanted the opposite: an empty directory, one command, and a provider that already knew how to sign its answers.

That tool now exists on PyPI as create-aimarket-agent 0.1.0 — a standalone scaffolder for AIMarket Protocol v2 capability providers. Docs in five languages. Generator CI claims 47 tests and 100% branch coverage. MIT.

It does not publish you to a marketplace. That part stays manual on purpose.

One command. Stable names.

uvx create-aimarket-agent my-agent --kind tool --metis
cd my-agent
uv sync --extra dev
uv run python configure_provider.py
uv run pytest
uv run python validate_manifest.py
uv run python agent.py

The CLI, flags, filenames, and API fields stay English everywhere. Localization covers the docs, not the contract.

Kinds:

create-aimarket-agent my-tool --kind tool
create-aimarket-agent my-data --kind data-provider
create-aimarket-agent my-orchestrator --kind orchestrator
create-aimarket-agent my-agent --no-metis

Scaffolding is atomic: stage in a temp folder, rename into place, clean up. A failed copy leaves no half-written repo.

Project names are allow-listed before they touch source or JSON. That sounds boring until the first time a fancy name breaks a Dockerfile.

What lands on disk

Path	Job
`agent.py`	FastAPI `/health` + `/invoke`
`capability.json`	Protocol v2 manifest
`provider_signing.py`	Persistent Ed25519 identity + request-bound signatures
`configure_provider.py`	Writes `provider_pubkey` into the manifest
`validate_manifest.py`	Fail-closed checks before you even think about publish
`test_agent.py`	API, signature, request-size tests
`Dockerfile`	Non-root image, key volume at `/data`
`.github/workflows/test.yml`	CI for the generated project

The default manifest looks like this (placeholders replaced with your slug):

{
  "product_id": "my-agent",
  "capability_id": "my-agent.invoke@v1",
  "name": "my-agent",
  "description": "A generated AIMarket tool capability",
  "invoke_url": "http://127.0.0.1:8080/invoke",
  "publisher_id": "community",
  "provider_pubkey": "",
  "price_per_call_usd": 0.001,
  "input_schema": {"type": "object", "additionalProperties": true},
  "output_schema": {"type": "object", "additionalProperties": true},
  "verification": {"metis": true}
}

configure_provider.py fills provider_pubkey. validate_manifest.py rejects duplicate JSON keys, broken Ed25519 keys, non-finite prices, bad URLs, and public HTTP endpoints before you ship.

The skeleton /invoke only accepts the product and capability ids declared in its own manifest. An untrusted caller cannot make your key sign someone else’s identity.

The part I actually cared about: the stamp

Pretty agents are easy. Replay-resistant receipts are not.

The generated signer keeps a 32-byte Ed25519 seed at mode 0600. Symlinks and non-regular files get rejected. Responses sign a canonical envelope with:

capability_id
product_id
SHA-256 of the input
the result

That binding is the point. Steal a response for request A and it should not verify as a reply to request B.

The signature is a receipt for what this provider returned. It is not an authorization gate for random internet callers. Keep 8080 on loopback until real HTTPS ingress, concurrency, and rate limits sit in front.

Docker without drama

docker build -t my-agent .
docker run --read-only --tmpfs /tmp \
  -p 127.0.0.1:8080:8080 \
  -v my-agent-key:/data my-agent

Runs as UID 65532, health-checks /health, stores the key under /data/provider.key.

Back up that key before you register anything. Rotate it and the Hub’s stored provider_pubkey becomes a stranger.

From skeleton to something useful: THEMIS

The README does not stop at “echo hello.” There is a full tutorial that turns the scaffold into THEMIS — a procurement gate that answers:

Should this candidate agent be approved, sent to human review, or rejected?

Deterministic policy checks. Projected cost. OWASP Agentic risk mappings. Optional lazy Metis verification that never silently overrides the verdict. Same request-bound signing model.

Tutorial: docs/tutorials/themis.en.md
Finished repo: alexar76/themis

If you only want a tool capability, ignore THEMIS. If you want a real admission gate, start there.

What this is not

Not auto-publish. Stake, publisher identity, trust policy, and Hub registration stay explicit operator steps.
Not “the monorepo.” The GitHub repo is a read-only mirror of the AI-Factory tree. PRs there get overwritten on the next sync — open an issue instead.
Not a substitute for HTTPS. Loopback + signature ≠ production exposure.

Try it

uvx create-aimarket-agent my-agent --kind tool --metis

Docs: alexar76.github.io/create-aimarket-agent
Source / issues: github.com/alexar76/create-aimarket-agent
Package: create-aimarket-agent on PyPI (0.1.0 as of this writing)

Empty folder in. Signed provider out. Marketplace listing still your call — which is exactly how I wanted it.

I connected one MCP server. It searched a live marketplace and returned a signed weather receipt.

Alex — Fri, 21 Aug 2026 11:54:52 +0000

Most MCP tutorials stop at “install another server.”

I wanted the opposite: one remote MCP, two tools, and a receipt I could keep — without adding a new server every time an agent needed a different capability.

So I pointed a client at the Official MCP Registry entry for aimarket-hub, opened the live remote, and asked for weather.

Two tools. That is the whole door.

The Hub MCP exposes exactly two tools:

market_search — plain-language intent → capability ids, prices, source_hub
market_invoke — call one capability; trial invokes first; then paid access

Remote URL (streamable HTTP):

https://modelmarket.dev/mcp

No monorepo tour. No “install seventeen servers.” Search, then invoke.

Find it on the Official Registry

On the Official MCP Registry, search aimarket-hub.

Live pull (2026-08-21):

name: io.github.alexar76/aimarket-hub
status: active
published: 2026-08-16
remote: https://modelmarket.dev/mcp
tools: market_search · market_invoke

Do not invent a server from a blog post. Take the registered remote.

market_search: ask in English

I called market_search with intent:

attested weather reading

Back came (among others):

Field	Value
capability_id	`gaia.weather.read@v1`
product_id	`gaia.gateway`
price_per_call_usd	`0.001`
source_hub	`https://iot.modelmarket.dev`

Search is a catalogue. It is not a forecast. Read the description before you spend a trial.

When I searched hydrology earlier, a flood SKU said out loud: not an in-situ river gauge. That sentence is the product.

Pass source_hub. Or the hub refuses.

Most of the catalogue is federated. Not local to the hub.

I tried market_invoke with the same capability id and no source_hub.

The answer was blunt:

gaia.weather.read@v1 is federated, not local — retry with source_hub="https://iot.modelmarket.dev"

That refusal is honesty. Not a bug. Pass what search gave you.

market_invoke: a real reading + a receipt

Then I invoked with:

capability_id: gaia.weather.read@v1
source_hub: https://iot.modelmarket.dev
input.device_id: om-wx-01

What came back (this run, 2026-08-21):

device: om-wx-01
site: live-weather-eu
temperature: ~21.5 °C
Ed25519 attestation on the reading
Hub receipt (signed)
sandbox: trial invoke (max_trials = 5)

The receipt outlives the chat tab. Keep it.

Trial then paid. Then 402.

The public remote grants a short trial allowance.

When the allowance ends, the hub answers 402. It does not invent a weather reading to keep the demo pretty.

Empty payment is still an honest answer.

What this is not

Not a new MCP server per SKU
Not a flood model / weather cinema
Not “trust the JSON forever”
Not a monorepo pitch

It is a door: registry → two tools → signed invoke.

Human doors (maps, build paths, investor intro) live on use.modelmarket.dev. The agent door for this article is the Hub MCP.

Try it

Open registry.modelcontextprotocol.io → search aimarket-hub
Point your MCP client at https://modelmarket.dev/mcp
Call market_search with a plain intent
Call market_invoke with source_hub
Keep the receipt

If something fails closed, read the message. That is the feature.

I unzipped the sample fire brief. The globe was never the product.

Alex — Wed, 19 Aug 2026 18:47:03 +0000

Last week I wrote that pretty fire maps are liars. People liked the tantrum. Then they asked the adult question:

So what do you actually keep?

The globe is the shop window. The product is a zip you can email.

I downloaded the sample. It says sample.

emberlinedesk.com/sample is labeled MARKETING FIXTURE. The page says this is not a live Hub invoke. We did not dress a demo as this morning’s run.

Cream paper. Three stamps. A small table that says two dots appeared and one got brighter. Then a button: download the pack.

The button is the whole movie.

Eight files. That is the desk.

I saved sample-cite-pack.zip. Ten kilobytes. I unzipped it.

00-README.txt
01-cover.pdf
02-brief.json
03-delta.json
04-receipt.json
raw/fire_weather.json
raw/watchbox.json
SHA256SUMS

On this sample, raw/watchbox.json is null. The fixture packed the fire snapshot, not a second Hub call.

No shapefile of “the fire.” No house-shaped flame. No forecast with a confidence gradient that photographs well on LinkedIn.

A README that tells intake how to cite: brief id, generated_at, evidence status, receipt digest. If you need the Hub payload, use raw/ — do not redraw geometry the desk did not store.

The human page

01-cover.pdf is the thing you can print without being a coward.

Header on every page: not a perimeter, not a forecast, not an evacuation order. Quiet is not proof of safety.

This sample is watch CA Transmission Corridor, brief brf_sample_001. It reports 152 LIVE FIRMS detections, brightest 367 K near 37.66, −121.38. Source-attributed context. Not containment. Not an evacuation.

The cover prints the receipt panel as stored — including emberline_verified=False on this fixture. We did not paint a green check for the brochure.

The delta is not a spread model

03-delta.json compares two briefs on the same box.

150 → 152 (+2). Two points appeared. One brightened 355 → 367 K. Zero disappeared.

That is the whole plot. The file says so out loud: this is not growth rate, not containment, not “the fire moved.” A disappeared point might be cloud. An appeared point is a new thermal anomaly in the box, not a confirmed ignition time.

If you cannot live with that sentence, you wanted cinema.

Hashes, because next quarter exists

Hashes match the files in this zip. Verify SHA256SUMS against every file except itself. The public sample is a fixture — it restamps generated_at on download. A filed brief’s pack keeps the same bytes.

This is the hardware-store receipt in the kitchen drawer. You email the zip. Intake hashes it in October. You do not argue with a screenshot of a globe.

The file outlives the tab.

What this is not (again, on purpose)

It is not 911.

It is not an insurance quote.

It is not “AI predicts where the fire goes next.”

Emberline is an independent desk. It buys the snapshot. It sells the watching. The rails underneath are not the brand on the paper.

If you only remember one sentence

The globe is the shop window. The product is a zip you can email.

Open the sample: emberlinedesk.com/sample → Download sample pack.

If you have a real box — a corridor, a ranch, a right-of-way, not “California” — request a key. No self-serve carnival.

Previous tantrum about the pretty blob: here.

The snapshot glass, if you still like staring at the planet: atlas.modelmarket.dev.

—
Emberline — a fire evidence desk. Independent. Citeable. Allergic to red blobs.

Pretty fire maps are liars. I wanted a file I could actually show someone.

Alex — Tue, 18 Aug 2026 08:37:15 +0000

You know the weather app that paints half the county red and calls it a storm.

Fire maps do the same trick. A smooth red blob. A glow. A shape that looks like the fire.

It is not the fire.

It is a drawing someone made around a handful of hot dots from space. The dots are real. The blob is interior design.

The pretty lie

If a smoke alarm beeps, you do not sketch a house-shaped flame and tape it to the fridge.

You look at which room. You look at how hot. You do not pretend you know the outline of the fire.

This is what most dashboards sell you. It photographs well. It does not survive a lawyer, an editor, or an awkward Tuesday on a call.

Satellites sell heat. Tiny points. Brightness. A maybe.

The product UI quietly upgrades that into containment. Containment is a job for people on the ground with a radio. A website does not get to invent it because red looks decisive.

The boring version (the good one)

Same hills. No blob. Dots, stamps, and a sentence that sounds like a nervous aunt:

Not a perimeter. Not a forecast. Not an evacuation order.

Ugly on purpose. You can email this. You cannot accidentally brief a board with a cartoon.

Last month I asked a fire API for evidence. It handed back 152 heat detections and refused to connect them. People liked the refusal.

A snapshot is still a snapshot. It dies when you close the tab.

So we built the unsexy thing next: a desk.

You name a box you actually watch — a corridor, a ranch, a right-of-way, not “California.” On a schedule it buys the attested snapshot, writes a brief, files it, and keeps the receipt. When the sky is quiet it says so. It does not fill the silence with last week’s glow, like leftover soup.

A sample you can open in pajamas

This is a sample. It says so on the page. We did not dress a demo as this morning’s live run.

Cream paper. Three stamps. A small table that says two new dots showed up and one got brighter. That is the whole movie.

If a dot disappears, the brief does not yell “the fire went out.” Clouds exist. Sensors blink. Adults can live with that.

The download is a cite pack — a zip, like keeping the hardware-store receipt in a kitchen drawer. Map of dots. Weather on a leash (only nearby, not “vibes”). A signed stamp for who printed this. Not “the sky is on fire, signed, God.”

The product is the file you can keep. The globe is just the shop window.

What this desk is not (say it like you mean it)

It is not 911.

It is not an insurance quote.

It is not “AI predicts where the fire goes next.”

It is not a first-party storefront for the rails underneath it. Emberline is its own little shop. It buys the snapshot. It sells the watching.

Open the sample. If you have a real box, request a key. No self-serve carnival, on purpose.

If you only remember one sentence

Pretty maps invent shapes. Audits do not.

Try the sample: emberlinedesk.com → Read a sample brief.

The snapshot glass, if you like staring at the planet: atlas.modelmarket.dev.

Previous tantrum about the 152 dots: here.

—
Emberline — a fire evidence desk. Independent. Citeable. Allergic to red blobs.

I asked for fire evidence. The API returned 152 thermal detections — and refused to draw a perimeter.

Alex — Sun, 16 Aug 2026 16:11:30 +0000

Most wildfire dashboards imply a shape the sensor never gave.

A red polygon looks like a perimeter. FIRMS never sold you a perimeter. It sold you thermal anomalies — brightness, confidence, a point — and a lot of product UIs quietly upgrade that into “the fire.”

We build agent rails where a screenshot is not evidence. So we shipped a vertical product that stays honest:

atlas.fire.weather@v1 — FIRMS detections (and EFFIS when present) + bounded LIVE weather context + a signed content receipt.

Not a burn scar. Not a forecast. Not a parametric quote.

The thesis (one sentence)

If your fire map invents a perimeter, it is cinema — not evidence.

What we actually returned (this run)

Public demo bbox (roughly West Coast US). One live invoke of atlas.fire.weather@v1:

Field	Value
LIVE FIRMS detections	152
Brightest	367 K near 37.66, −121.38 (confidence 90)
EFFIS polygons	0 in this frame
Weather	LIVE nearest in range — SFO Airport, 15 °C
Price (public demo)	~$0.08

Count the detections. Do not invent a line around them.

Weather is on a leash — only inside a declared distance bound, not a global vibe:

Dual attribution: thermal list + weather list. Same receipt discipline.

Open the glass

atlas.modelmarket.dev — layers fire + weather, English UI
Or the idea path: use.modelmarket.dev → Fire + Weather Evidence Snapshot
Hub SKU: atlas.fire.weather@v1

Humans get honesty on the map. Agents buy the artifact behind it.

Curl shape (ATLAS invoke):

curl -sS -X POST https://atlas.modelmarket.dev/ai-market/v2/invoke \
  -H 'Content-Type: application/json' \
  -d '{"capability_id":"atlas.fire.weather@v1","input":{"west":-125,"south":32,"east":-114,"north":42,"limit":24}}'

What it is not (say it out loud)

We print the limits on the artifact on purpose:

FIRMS reports satellite thermal anomalies — not confirmed incident perimeters.
EFFIS current-fire polygons are a separate Copernicus product (CC BY 4.0) when present — not FIRMS pixels.
Weather / air context only within declared distance bounds.
Independent operational validation is still required.

That paragraph is the product. Dashboards that skip it are lying by omission.

Evidence with a receipt

The snapshot carries a content receipt — digest, signature, public key. Same grammar as our portable proofs post: the object can leave the tab.

Attribution ≠ physical truth. A valid receipt proves who signed these claims — not that the sky is on fire.

Sibling SKUs on the same rails: Verified Watchbox (atlas.watchbox.check@v1) for region queries; Fire Glass for the vertical evidence pack.

Live wedge. Not a slide.

Why this is the showdev version of “AI + wildfire”

Agents are about to buy physical-world context at micro-prices. If the first product they touch upgrades detections into perimeters, we train them to trust theater.

We would rather ship:

cited detections
bounded context
a fail-closed empty box when LIVE is gone
a receipt you can keep

Boring. Citeable. Useful.

Try it

atlas.modelmarket.dev/?layers=fire,weather
use.modelmarket.dev → Fire + Weather path
Repo (MIT): github.com/alexar76/aicom

If it helped, a ⭐ is the softest thank-you. Brutal feedback on the limits copy is better.

—
AIMarket — verifiable provenance · agent economy · crypto optional

I ran a live agent invoke. Here's a URL you can verify without trusting our site.

Alex — Thu, 13 Aug 2026 17:02:46 +0000

Most demos end as a screenshot.

You click a button. Something green appears. You believe the author — or you don't. Tomorrow the tab is gone, and the “proof” is a PNG in a blog post.

We already ship live rails for an agent economy: attested readings, pay-per-call invoke, settlement that can refuse to pay. What was missing was a portable object after the click — something a stranger can reopen, fetch as bytes, and check offline.

So we closed that loop.

use.modelmarket.dev → Run live request → portable AWR/2 receipt → verify.modelmarket.dev with ?receipt_url=…

No account. No “trust our backend.” The Hub seals a signed work receipt; the verifier checks the signature in your browser.

The thesis (one sentence)

If your proof dies when the tab closes, it was never a proof — it was theater.

What you touch (two minutes)

Open the portal. Stay on EN. Scroll to Live proof.

Same weather capability the catalogue sells (~$0.001). The public demo still shows the catalogue price; sandbox demos are charged $0 with a remaining-request counter.

Click Run live request.

You get a signed reading — device, seq, Ed25519 attestation, latency — and then the part that matters:

“The object survives this tab.” Copy proof link · Verify signature locally · Open receipt JSON.

That purple card is not a UI flourish. It is a W3C Verifiable Credential (AWR/2) issued by the Hub (did:key:…), with a canonical receipt_url on the marketplace host.

What “portable” means here

Step	What happens
01 LIVE	A real reading (e.g. `om-wx-01`)
02 GAIA	Attested envelope (Ed25519 · seq)
03 HUB	Seals an AWR/2 work receipt + public `receipt_url`
04 VERIFY	Anyone opens the verifier with that URL

The share link looks like:

https://verify.modelmarket.dev/?receipt_url=https://modelmarket.dev/ai-market/v2/p/provenance/receipt/urn:uuid:…

Paste it in another browser. Incognito. Someone else's machine. The verifier fetches the JSON and checks eddsa-jcs-2022 locally.

L0 on purpose: signed by its issuer, and nothing more. No TEE theater on this demo path.

What a valid receipt proves — and what it does not

This is the line we refuse to blur:

It proves: this issuer signed these claims, and the bytes were not altered.

It does not prove: that the physical sensor is truthful, that the model “really ran,” or that the weather outside your window matches the number.

Attribution ≠ physical truth. Pay-on-Verified settlement and LIVE vs SIM labeling on ATLAS exist for the honesty gaps a signature alone cannot close.

Humans get honesty on a map. Agents buy the reading behind the pin. Same provenance grammar.

Why this changed the portal

The five doors article was about finding the rails.

Portable proofs are about leaving with evidence.

HN comment, investor chat, design-partner email — you no longer paste vibes. You paste a URL that either verifies or fails closed. That is the Basescan-shaped habit for physical invoke: citeable, durable, boring in the best way.

Same pattern lands on the idea lab demos (Fire + Weather, Verified Watchbox): invoke → capsule → verify. One object class everywhere.

Try it

use.modelmarket.dev → Run live request
Copy proof link or Verify signature locally
Optional: curl the same SKU from the page (visitor header included in the snippet)

Repo (MIT): github.com/alexar76/aicom

Verifier source / npm: @alexar76/awr-verify

Map: atlas.modelmarket.dev

If it helped, a ⭐ on the repo is the softest possible thank-you. Brutal feedback on the proof UX is better.

—
AIMarket — verifiable provenance · agent economy · crypto optional

Five doors into a live agent economy — no monorepo tour

Alex — Wed, 12 Aug 2026 11:50:52 +0000

Most “AI ecosystems” hand you a README mountain and a Discord.

We already ship the rails: Hubs that index capabilities, agents that pay per call, oracles that settle only when the world was honest, a red team that signs findings and cannot pay itself. What was missing was a door humans can open in three minutes — without cloning the monorepo.

So we built one.

use.modelmarket.dev — five doors into live links:

See · Buy · Publish · Build · Invest

One path. Live surfaces. Status chips that mean something. Not slideware.

The thesis (one sentence)

If an agent economy needs a guided tour to feel real, it isn’t ready for strangers.

Developers bounce on architecture diagrams. Investors bounce on “roadmap.” Operators bounce on unlabeled green pins. The portal’s job is narrower: pick a door, touch a rail that already exists, leave with a receipt or a map — not a TED talk.

Onboarding is a door picker, not a setup wizard. Language stays English on broad shoots.

What the ecosystem already feels like

One job per card. Live link. No monorepo pitch.

Two cards that actually work:

Door	What you touch	Why it matters
See	ATLAS	Pins are LIVE or SIM — never mixed without a badge
Buy	Weather / oracle invoke	~$0.001 readings; settle only when honest

That honesty grammar is the product. A map that lies is worse than no map. We learned that on GAIA (silence → $0) and we keep it on glass.

See — planetary glass, not another dashboard

Open ATLAS. Switch a layer. Weather. Air. Quakes. Same rails, different capabilities.

Fleet glass: LIVE vs SIM counts in the chrome. Demo campus stays labeled SIM.

Humans get honesty on a map. Agents get the same provenance when they buy a reading. That is the point of “attested” — not a marketing adjective.

Buy — pay for a fact, not a vibe

The physical path is boring on purpose: invoke → verify → settle (or refund). Crypto stays optional for the lesson; the shape is the product.

Pay-on-verified. Silence and lies don’t get to keep the money.

If you only remember one number from the portal: a weather reading you can actually buy for about a tenth of a cent — and a settlement path that refuses to debit when the sensor was lying.

Publish · Build · Invest — the other three doors

Door	Who it’s for	What you get
Publish	Capability authors	A path onto the Hub — discoverable, callable, receipted
Build	Product builders	7 boards · 12 wedges with honest maturity chips (live / build-ready / design partner / hypothesis)
Invest	Operators & capital	Adjacent markets + sources + disclaimer first — serious talks follow from what already ships

Build boards are cut on purpose. The rest was deleted so the map stays legible.

We do not present hypotheses as shipped products. Status chips are evidence maturity — not market size cosplay.

How this sits next to the rest of the house

The portal is a front door, not a rewrite.

Factory / ARGUS — demand and supply agents on the same economy
WARDEN — fail-closed MCP before tools reach the model
MOMUS — signed findings; cannot pay itself
SKOPOS — fleet watch + fix-loop conductor
Signal Hunt — federation literacy as a detective game on live Hub telemetry
Alien Monitor — the economy as a place you can walk

If you already read the red-team post or the 3D surfaces post, this is the human on-ramp those pieces assumed.

Soft star

If a portal with five live doors is more useful than another agent README — a star helps the house travel.

⭐ github.com/alexar76/aicom · Portal: use.modelmarket.dev · Map: atlas.modelmarket.dev

Pick a door. Touch the rails.

No monorepo tour.

The federation emitted a signal. Find the cause — a detective game on live Hub telemetry

Alex — Tue, 11 Aug 2026 17:04:02 +0000

Most “AI literacy” products are slideshows with a quiz at the end.

We already run a live agent economy — Hubs that index capabilities, peers that join and leave, prices that move, provenance that either exists or doesn’t. Operators keep misreading that glass: a green pin that means SIM, a quiet peer that means gone, a catalogue that looks rich because one source is dumping tools.

So we wrapped the real telemetry in a hunt.

Signal Hunt is a federation-native detective game — and an educational lab. Every round starts from a measured Hub snapshot. You open evidence (it costs score). You commit a diagnosis and a confidence. The server reveals a precommitted salt, recomputes a Brier score, and signs the milestone.

No fixtures. No placeholder catalogue. If the Hub cannot be observed, the round is unavailable — not “all clear.”

Play: hunt.modelmarket.dev · Source: github.com/alexar76/signal-hunt (MIT) · Landing: alexar76.github.io/signal-hunt

The thesis (one sentence)

Federation literacy is a skill — and skills get worse when the tutorial invents the world.

Green UI is cosplay unless the numbers come from a living Hub. Fake confidence is worse than a wrong call. Signal Hunt punishes both.

Landing: LIVE TELEMETRY · Ed25519 · Brier · measured state only.

Four moves. One verifiable verdict.

The protocol is deliberately short:

Move	What happens
01 Observe	Node records a live Hub manifest — sources, prices, provenance, state hash
02 Investigate	Open only the evidence you need; each reveal is committed and costs score
03 Commit	One diagnosis + confidence (25–100%). One submission per round
04 Verify	Salt revealed. Brier recomputed. Milestone signed

Nothing in the result depends on a hidden moderator or invented telemetry.

Six evidence blocks sit behind the glass: distribution · historical change · pricing · peers · latency · provenance. Curiosity is not free. That is the pedagogy.

A sealed field reading is ready

The detector class stays hidden until you commit. The answer was salt-committed before you acted. You are not negotiating with a GM — you are racing a precommitted world.

Round sealed. Open evidence. Choose a diagnosis. Verify against the commitment.

Diagnoses map to real federation dynamics — isolation, disappearance, peer churn, latency weather, concentration, and friends. After a few rounds you should be able to say why a Hub looks the way it does from measured sources, not from vibes.

Fake confidence loses on purpose

Correctness alone is not enough. You state a probability. The server scores you with Brier. Calibrated confidence is rewarded. Bluffing certainty is punished. Math — not a moderator.

Salt revealed. Commitment independently verifiable. Score is earned, not narrated.

When a verdict lands, you can recompute it from salt, commitment, and returned operands. That is the whole point of sealing the answer early: reproduce the result.

Astral progression — cosmetics, not money

Progression is astral: Stargazer toward Pathfinder. Score comes from verified rounds. A season passport tracks the week — distinct diagnoses, PRIME corrects, streaks.

Relics are deterministic records. Nothing is minted. Cosmetics only. Empty hero feed is honest: nobody opted in yet — not a fake leaderboard.

Climb by being right — and calibrated. Season passport is a ledger of skill, not a wallet.

Heroes of the signal only publish opt-in milestones from signed, verified verdicts. DIOSCURI can relay to Discord / X — only with explicit consent. Share proof. Never invent impact.

Why this sits next to the rest of the economy

Signal Hunt is not a side quest bolted onto a blog.

It runs against an ordinary AIMarket Hub (same family as the competing lab / USE portal). The game registers local capabilities (signal.case, signal.evidence, signal.submit, …) and discovers remote tools through the Hub when they exist. Failure is recorded as unavailable — never dressed up as a successful call.

If you already know ATLAS (LIVE needs provenance; SIM stays labeled) and GAIA (silence → $0), this is the same honesty grammar — aimed at operators reading federation glass, not at settlement physics.

Crypto stays optional for the lesson. The shape is the product: observe → pay for evidence → commit → verify.

Soft star

If this is your kind of lab — a detective loop on live rails instead of a fixture tutorial — a star helps the repo travel.

⭐ github.com/alexar76/signal-hunt · Play: hunt.modelmarket.dev

The federation emitted a signal.

Find the cause.

We put a red team inside our agent economy. It finds bugs, signs them, and cannot pay itself.

Alex — Mon, 10 Aug 2026 13:30:17 +0000

Most agent stacks have a blue team fantasy and a red team PowerPoint.

We already shipped the blue team: WARDEN inside ARGUS fails closed on poisoned MCP tools before descriptions reach the model. That still left a hole. Who continuously attacks our own house — oracles, settlement gates, manifests — and leaves evidence anyone can verify offline?

MOMUS is that hole, filled on purpose.

It is a tolerated adversary living in the AICOM / AIMarket ecosystem. It runs safe, read-only probes. It emits Ed25519-signed findings. And the property that matters most:

It finds and signs — and it is structurally unable to pay itself.

Live panel (no login theatre): momus.modelmarket.dev · Source: github.com/alexar76/momus (MIT)

The thesis (one sentence)

An agent economy you cannot audit from the inside will eventually audit you from the outside — usually after money moved.

Dashboards that only show “healthy” are cosplay. A red team that can also release its own bounty is a self-deal waiting to happen. MOMUS separates those keys on purpose.

Safe read-only probes against our own components. Scanner finds. Treasury pays. Key boundary in between.

What Momus wanted (and why we named it that)

In the myth, Momus (Μῶμος) faulted Hephaestus’s man for one thing: no window in the chest through which thoughts could be inspected. That is still the oldest argument for auditability.

MOMUS is that window for an economy of agents:

It does	It refuses
Probe allowlisted targets (oracles, hub, settlement, injection surfaces…)	Destructive attacks on strangers
Sign every finding (Ed25519)	“Trust me, I saw it”
Emit `FINDING` / `NO_FINDING` / `INCONCLUSIVE`	Fake green when a target is unreachable
Learn which probes pay off (UCB1 bandit + threat intel priors)	Pretend every scan is equally smart
Feed confirmed third-party patterns to WARDEN	Publish patterns that would DoS our own Hub

Red team and payer show up as their own nodes on the Alien Monitor — click through to the live panel.

The rule that makes it real: cannot pay itself

A scanner that can also move money is not an auditor. It is a conflict of interest with an API.

So:

Scanner key — signs findings. Never releases funds.
Treasury key — separate container, separate key. Only thing that can release a bounty.
Independent verification — HIGH/critical needs two distinct verifier keys, at least one registered external. The gate refused us the first time we tried with one. That refusal is the feature.
Dedup identity — one bug is never paid twice; rediscovery bumps seen_count.

Crypto stays optional. The shape is the product: find ≠ pay.

Honest outcomes beat wolf cries

Three first-class results:

FINDING — signed, reproducible probe path
NO_FINDING — contract held under that probe
INCONCLUSIVE — target unreachable / probe aborted — neither a pass nor a scare

A red team that turns silence into “all clear” is worthless. We already learned that lesson on the physical side with GAIA (silence → $0) and ATLAS (LIVE needs provenance; SIM stays labeled). MOMUS uses the same honesty grammar on the offensive side.

Red feeds blue: WARDEN knocks up, signed feed goes down

WARDEN already knew how to consume a signed threat feed (authenticity · freshness · RFC 8785 canonical bytes · fail-closed). MOMUS conforms to that contract — ARGUS needed no protocol rewrite.

Two directions, deliberately asymmetric:

	Up (field → MOMUS)	Down (MOMUS → field)
Who starts	any ARGUS install reports a suspicion	installs poll the feed
Trust	never — intake is a lead queue	document is signed; operator pinned the key
Effect	operator may promote a probe	WARDEN may deny a hostile MCP surface

Blue team still decides locally. Red team only publishes what it confirmed — and never a pattern that would deny our own house.

The self-restraint rule matters as much as the crypto: a signed feed that DoSes your own Hub is worse than no feed. First-party denylist is enforced and tested.

Docs: MOMUS → WARDEN channel

A finding is not a PDF — it is a fix loop

Scanners that stop at “open ticket in Jira” are half a product.

Confirmed findings become A2A remediation tickets. SKOPOS conducts. The Factory writes under a ticket. MOMUS retests the same probe as the deploy gate. Only then does a signed DeployOrder become something a node agent may claim — one command, not a blank check to merge main.

SKOPOS is not only a traffic globe. In the loop it is the conductor.

Watcher’s eye stays on. The hand that moves is remediation.

Agents write under a ticket. Operator authority still owns what lands on main. Dry-run honesty on camera.

What we actually proved on production

On 2026-08-08 a full find → verify → fix → gate cycle ran end-to-end on the live MOMUS deployment.

Honesty clause (read this before the wow):

The finding was real — ordinary probes, real HTTP, real production scanner key, offline-verifiable signature.
The target was a canary — a fixture that knows how to break its own contract so the pipe can be seen to fire. Production oracles/hub scanned the same day and passed.
Settlement was UNI / simulated — no real money moved. The gates still refused a one-verifier payout attempt before a two-verifier run cleared.

That documentation lives in-repo with real IDs: docs/first-cycle.md.

The value of a gate is what it blocks. We are prouder of the refusal than of the happy path.

LOGOS: the brain that asks (and does not rewrite)

Once you have a red team and a fix loop, operators still drown in tabs. LOGOS is the federation analytics brain — natural-language questions over hubs, scanners, treasuries, reputation — read-only by construction.

“How long will the Treasury last?” / “Which hub has critical findings?” — asked, not grepped.

It polls MOMUS and Treasury into one glass. It does not remediate. Fix loops stay with MOMUS + SKOPOS. Separation of concerns is the trust feature, not a missing button.

Live: logos.modelmarket.dev · Source: github.com/alexar76/logos

How the pieces fit (no architecture cosplay)

Field ARGUS ──report suspicion──▶ MOMUS intake
                                      │
                                 confirm + sign
                                      │
                    ┌─────────────────┼─────────────────┐
                    ▼                 ▼                 ▼
              WARDEN feed      SKOPOS ticket      LOGOS poll
             (deny MCP)      (Factory patch)    (ask / alert)
                                      │
                               MOMUS retest gate
                                      │
                                 DeployOrder

Crypto-light on the broad cut. The story is keys, gates, and honesty — not a token pitch.

Soft star if this is your missing organ

If you want…	Soft ⭐
The auditor that cannot self-deal	github.com/alexar76/momus
The firewall that consumes the feed	github.com/alexar76/argus
The conductor + fleet watch	github.com/alexar76/skopos
The read-only federation brain	github.com/alexar76/logos

Live panels: momus.modelmarket.dev · skopos.modelmarket.dev · logos.modelmarket.dev

MIT. Self-hosted. Run the probes yourself.

Closing

We did not need another dashboard that says the agents are fine.

We needed a window in the chest — an adversary we tolerate on purpose, that signs what it finds, that cannot bribe itself, that feeds the firewall, and that turns a finding into a loop that can refuse to deploy.

That’s MOMUS.

Verify, don’t trust.

I treat my agent stack like an art object — and the 3D isn't decoration

Alex — Thu, 06 Aug 2026 10:23:54 +0000

Most agent demos look the same: a dark terminal, a JSON blob, a green “200 OK.”

That UI is honest. It’s also how you stop seeing the system.

I build a self-hosted agent economy — factory, marketplace, mesh, oracles, physical sensors. At some point the logs stopped fitting in my head. Not because the code got mystical. Because the topology got real: thirteen agents in a pipeline, peers discovering peers, math oracles with provenance, weather pins that agents buy as capabilities.

So I started treating the surfaces like object art — not wallpaper, not a Dribbble flex. A thing you walk around. A thing that makes the invisible structure legible before you debug it.

Alien Monitor — the economy as a living graph, not a logfile.

The thesis (one sentence)

If a multi-agent system can’t be watched as a place, operators will only trust it when it’s small — and abandon it when it’s useful.

Pretty dashboards don’t fix broken escrow. 3D doesn’t replace tests. But a good surface does something logs refuse to do: it makes relationships obvious — who talks to whom, what’s LIVE vs SIM, where the receipt went, which node just went quiet.

That’s why we keep shipping “unnecessary” cinema.

Why Alien Monitor exists

When you run a factory + hub + mesh, failure modes don’t look like stack traces. They look like:

an agent that should have been discovered and wasn’t
a capability that got invoked with no settle
a peer that answered… with silence
a subgraph that pulsed five minutes ago and now sits dead

Alien Monitor is the wall for that. One graph. Invocations streaming. Nodes for SDKs, mesh, factory, ARGUS, GAIA — the whole constellation wired into a pulse you can feel without grepping four services.

The factory isn’t only a pipeline API. It’s a place you open like a control room.

Dashboards stay boring on purpose: health score, products, resources. The art is the graph; the ledger is the table.

I don’t open Monitor because it looks cool in a screen recording (though it does). I open it because topology bugs are social bugs — wrong neighborhood, missing edge, dead peer — and social bugs are faster to spot on a map than in CloudWatch.

Live: magic-ai-factory.com/monitor/

Why the oracles are 3D rooms (not function names)

We have seventeen math oracles — Platon, Fermat, Fourier, Turing, … Each one is a real capability an agent can buy: randomness, proofs, transforms, weird little gods of computation.

You could ship them as seventeen gray buttons.

We didn’t.

Each oracle gets a scene — a room with its own physics metaphor. Platon isn’t a /vrf endpoint in a table. It’s a cave of light you walk into. Fermat isn’t a docstring. It’s a surface that behaves like the math.

The portal at oracles.modelmarket.dev — doors, not docs.

Platon as a place. Agents still hit an API. Humans get a memory.

Same stack, different room. The differentiation is intentional.

Why bother? Because operators and buyers are still human. A marketplace of invisible functions collapses into noise. A constellation of rooms becomes a product people can point at — “go through that door.” The 3D is the packaging of trust: you remember what you entered, not only what JSON came back.

And yes — the receipts, signatures, and settle rules still have to be correct underneath. The art is the invitation. The protocol is the contract.

Why ATLAS puts Earth on glass

Season of the map: ATLAS sits over GAIA physical relays — weather, air, tide, quakes. Agents buy attested readings. Humans need to see that the pin is LIVE (has a provenance source) or SIM (honestly labeled).

A table of stations is correct. A dark globe with glowing pins is auditable at a glance.

Earth as product surface — not a slide background.

LIVE vs SIM badges in the wild: atlas.modelmarket.dev

Cinema of one fact: temperature, source URL, coordinates — the pin is a receipt you can click.

The 3D Earth isn’t there to cosplay NASA. It’s there so a fleet operator can ask: is the planet lying to my agents? Fake green is a product bug. Empty map is honesty. That distinction is almost impossible to teach with a README alone — and almost effortless on glass.

Object art, not cosplay

A few rules we try (and sometimes fail) to keep:

Every wow surface maps to a real subsystem. No decorative particles that don’t bind to data.
Beauty is a legibility budget. If the graph lies, burn it.
Crypto stays off the broad cut. The economy can settle however you configure — the art article doesn’t need a chain pitch.
MIT / self-hosted. You can run the rooms yourself. The aesthetic travels with the code.

This is the opposite of “AI slop UI” — purple gradients with no product underneath. If the Monitor goes dark, the factory is sick. If ATLAS shows SIM, you’re looking at a simulator on purpose. If an oracle door won’t open, the capability isn’t for sale today.

What to open if you only click three links

Surface	Why
Alien Monitor	Topology of the live economy
Oracles portal	Math as rooms you can enter
ATLAS	Attested world on a map

Factory / self-host: magic-ai-factory.com · source: github.com/alexar76/aicom

If the idea of instrumentation as object art resonates — a soft ⭐ on the repos you actually care about (aicom / atlas / argus / gaia) helps more than a polite like.

Built in the open. The screenshots are the product, not a mock.

Shrek owned the swamp. POUCHPO owns the payout.

Alex — Sun, 02 Aug 2026 19:03:31 +0000

Meet POUCHPO — a cute river king with an IoT crown.

https://www.youtube.com/watch?v=6IU1HhpBBGY

He sells attested weather.

He gets paid.

He buys oranges.

Physical oracle → physical lunch.

That's the whole myth. The engineering underneath is GAIA: agents buy Ed25519-attested sensor readings, and money moves only when physics agrees.

Live demo (no login): iot.modelmarket.dev

Serious write-up (same stack, less hippo): Your agent paid for the weather. The sensor was lying. Who keeps the money?

Why a hippo

Most "AI + IoT" posts open with a dashboard screenshot. Dashboards don't stick.

A bored hippo with a glowing sensor crown does.

POUCHPO is the story shape of a real settlement rule:

What happened	What the market does
Honest reading	provider gets paid
Lie / stuck / spike / drift	buyer refunded
Sensor silent / offline	no debit at all

Same Pay-on-Verified escrow we already use for verified LLM work — except the judge is not a language model. It's a plausibility verifier that speaks Metis's /v1/verify envelope.

The supplier arc (60-ish seconds)

Bored river king — mud, water, nothing to sell
IoT crown wakes — sensors for the living world
Readings bloom — temperature, humidity, the river's true mood
Attestation — signed at the device, not vibes in a JSON field
Agents shop — they need a reading they can trust
Settle — honest → payout · lie → refund · silence → $0
Oranges — cold, real, bought with verified weather

Absurd on purpose. The punchline is the product.

What you can actually call

Not a cartoon API. Paid capabilities on the AIMarket v2 wire:

Capability	What you get
`gaia.weather.read@v1`	T / RH / P / wind + device attestation
`gaia.air.read@v1`	PM2.5 / PM10 / CO₂ / VOC + attestation
`gaia.energy.read@v1`	V / A / W + monotonic Wh register
`gaia.verify@v1`	statistical plausibility verdict
`gaia.fleet.status@v1`	fleet registry (free)

curl -s https://iot.modelmarket.dev/ai-market/v2/manifest | jq '.capabilities_count'

curl -s -X POST https://iot.modelmarket.dev/ai-market/v2/invoke \
  -H 'Content-Type: application/json' \
  -d '{"capability_id":"gaia.weather.read@v1","product_id":"gaia.gateway","input":{"device_id":"ws-01"}}'

Honest caveat: the public demo fleet is simulated. The wire is real — manifest, invoke, receipts, provider signature, verify envelope, WoT Thing Descriptions. Unreachable device → no money movement.

Slogan lock

Shrek owned the swamp. POUCHPO owns the payout.

Tagline: Sells verified weather. Buys real oranges.

If your agent stack still debits on "JSON arrived," you're funding whoever can fake a sky. Hold the money until a twin / bound / history check agrees.

⭐ github.com/alexar76/gaia · demo iot.modelmarket.dev · map of the stack github.com/alexar76/aicom

POUCHPO is the myth. GAIA is the gateway. Oranges are non-negotiable.

Your agent paid for the weather. The sensor was lying. Who keeps the money?

Alex — Wed, 29 Jul 2026 21:57:46 +0000

"Just trust the JSON" is how most agent stacks treat the physical world. Temperature arrives. PM2.5 arrives. The agent bills, ships, decides. Nobody asks whether the sensor was stuck, spiked, or inventing a sky that never happened.

We already had two ways to ground an answer in the AI-Factory / AIMarket ecosystem:

Class	What it proves	How you check it
Math oracles	a computation	re-verify the proof, byte-for-byte
Metis	an LLM delivery vs buyer intent	council → verifier → `verify_score`
GAIA (new)	a reading from the world	physics bounds + history + co-located twin + Ed25519 device attestation

GAIA is the third class: a physical-world oracle gateway. Agents buy Ed25519-attested sensor readings as normal AIMarket capabilities. Settlement uses the same Pay-on-Verified escrow we already ship for LLM work — except the judge is not a language model. It is a sub-millisecond plausibility verifier that speaks Metis's /v1/verify envelope.

Honest reading → provider gets paid.

Lying / stuck / drifted sensor → buyer refunded automatically.

Unreachable device → no debit at all.

Live demo (no login): iot.modelmarket.dev · Source: github.com/alexar76/gaia (MIT)

The problem nobody budgets for

Agent A needs "current outdoor temp at site X" to decide whether to delay a delivery, adjust a quote, or trigger a physical workflow. Today the happy path is:

Call some weather API or IoT bridge
Parse temperature_c
Act (and often pay) as if the number is true

That works until it doesn't. Sensors fail in boring, expensive ways:

Stuck — ADC latch-up; six identical values to four decimals
Spike — EMI / loose wire; 12°C → 87°C between samples
Drift — slow miscalibration that never trips a z-score alone
Dropout — radio dead; callers retry into empty air and still get billed by naive bridges

If your agent economy debits on response, not correctness, a lying sensor is a profitable attack surface. You don't need fancy crypto drama for that — you need escrow that understands physics.

What GAIA actually sells

Not a dashboard. Not a "digital twin theatre." Paid capabilities on the AIMarket v2 wire:

Capability	Price (demo)	What you get
`gaia.weather.read@v1`	$0.001	T / RH / P / wind + device attestation
`gaia.air.read@v1`	$0.001	PM2.5 / PM10 / CO₂ / VOC + attestation
`gaia.energy.read@v1`	$0.001	V / A / W + monotonic Wh register
`gaia.window@v1`	$0.05	N readings in one invoke (clears ledger quantum)
`gaia.verify@v1`	—	statistical plausibility verdict
`gaia.fleet.status@v1`	free	fleet registry + pinned device pubs

Demo fleet: two weather stations (ws-01, ws-02) sharing one site truth — the twin is required for sibling checks — plus air quality and energy. Models imitate BME280 / SDS011 / SCD30 / Shelly-EM-class hardware.

Honest caveat up front: the public demo fleet is simulated. Every wire surface is real — manifest, invoke, receipts, provider signature, verify envelope, W3C WoT Thing Descriptions. Live public sensors (NOAA / OpenSenseMap / OGC SensorThings) ride the same attestation + verifier path in gaia/devices/live.py. Unreachable upstream → 503 → no debit.

Thirty seconds to a signed reading

curl -s https://iot.modelmarket.dev/ai-market/v2/manifest | jq '.capabilities_count'
# → 6

curl -s -X POST https://iot.modelmarket.dev/ai-market/v2/invoke \
  -H 'Content-Type: application/json' \
  -d '{
    "capability_id": "gaia.weather.read@v1",
    "product_id": "gaia.gateway",
    "input": { "device_id": "ws-01" }
  }'

You get back something like:

{
  "ok": true,
  "output": {
    "reading": {
      "device_id": "ws-01",
      "model": "GAIA-WS1 (BME280-class + anemometer)",
      "site": "demo-site-1",
      "seq": 1,
      "ts": "2026-07-29T20:55:24Z",
      "values": {
        "temperature_c": 12.2365,
        "humidity_pct": 66.3611,
        "pressure_hpa": 1013.8333,
        "wind_mps": 3.108
      }
    },
    "attestation": {
      "algorithm": "ed25519",
      "public_key": "ndZPK7zIWdK+xFQMDOfPCaCValSOWrpCzs/DmzHN4C0=",
      "value": "…",
      "canonical": "device|model|seq|ts|values_sha256"
    }
  },
  "price_usd": 0.001,
  "receipt": { "nonce": "…", "signature": { "algorithm": "ed25519", "value": "…" } }
}

Three signatures, three claims:

Device → reading — per-device Ed25519 over device|model|seq|ts|values_sha256
Gateway → response — request-bound X-Provider-Signature (input hash included)
Hub → settlement — verification envelope signed after the verdict

On real hardware the device key moves into a secure element / TEE — the slot the AIMarket protocol already reserves. Plausible numbers from an unproven sensor are worth nothing; identity is layered under the statistics.

Pay-on-Verified, but the judge is physics

Pay-on-Verified is buyer-opt-in escrow on the hub: hold funds, return the provider output immediately, move money only after a machine verdict.

For LLM work the judge is Metis.

For sensors the judge is GAIA's /v1/verify — same envelope shape, so the hub does not care which one is plugged in:

export AIMARKET_VERIFY_METIS_URL=http://gaia-host:9320
export AIMARKET_VERIFY_VERIFIER_ID=gaia.verify@v1

End-to-end:

Buyer invokes gaia.weather.read@v1 with a verify block (intent + wait policy)
Hub calls GAIA → attested reading returned
Hub holds the channel funds (does not debit yet)
Settlement worker POSTs GAIA /v1/verify with the audit string
Pass → capture hold, verify_passed reputation event
Fail → release hold, signed rejection receipt with trace_id: gaia_…, verify_failed
Dropout / 5xx → no hold, no debit

Guaranteed in-process by gaia/tests/test_hub_e2e.py: honest → capture at the 1¢ ledger quantum; spiked → output delivered but hold released; dropout → 502 and an untouched balance.

That is the product thesis in one line: agents pay for weather that happened, not weather that was imagined.

How a sensor gets convicted (no LLM)

The plausibility verifier is deterministic. Identity first (unknown device or bad attestation → score 0.0). Then every field independently. Then MIN over fields — not mean — because a sensor lies one channel at a time, and averaging would let three honest fields launder one fabricated one.

Hard checks (physics, not vibes):

bounds within [lo, hi]
monotonic energy register never decreases
stuck: 6 identical values on a continuous field
schema: known field, numeric value

Soft checks (statistics that know when to abstain):

z-score vs own history (≥ 24 samples; skip bursty fields like wind_mps / power_w)
rate vs jitter + slope × Δt
sibling agreement with the co-located twin (fresh ≤ 10 min)

Threshold default: 0.7. Traces name the check that failed (zscore:temperature_c, sibling:humidity_pct, …) — a refund says which physics convicted the sensor, not just a vibes score.

Fault injection maps failures onto the check that catches them:

`POST /sim/fault`	Simulates	Caught by
`stuck`	dead sensor / ADC latch	`stuck:*`
`spike`	loose wire / EMI	`zscore` + `rate` + `sibling` (+ `bounds` if absurd)
`drift`	ageing / miscalibration	`sibling:*` (slow drift evades z-score alone)
`dropout`	power / radio loss	503 → hub 502, no money movement

Honest readings on all four demo devices score ≥ 0.9 in the unit suite. Forged attestation zeroes the score. Unknown device rejected. See test_attestation_and_plausibility.py.

Why this is not "another oracle blog post"

Most "AI + IoT" writeups stop at charts. The interesting engineering is the interface reuse:

GAIA returns the full Metis-shaped {status, verified, verify_score, route, trace_id, …} envelope
Engine errors stay HTTP 200 with status: "error" (never 5xx) so the hub's bounded-retry + fail-open/closed policy applies unchanged
Reputation events from verify pass/fail feed the same trust graph (LUMEN) that already prices agent reputation elsewhere in the stack
WoT Thing Descriptions sit beside the AIMarket manifest — industrial IoT tooling and agent tooling share one device identity

Math oracles prove compute. Metis judges language. GAIA grounds settlement in the world. Same market. Same escrow. Different ground truth.

Try it

docker pull ghcr.io/alexar76/gaia:latest
docker run --rm -p 9320:9320 ghcr.io/alexar76/gaia:latest

curl -s localhost:9320/.well-known/ai-market.json
curl -s -X POST localhost:9320/ai-market/v2/invoke \
  -H 'Content-Type: application/json' \
  -d '{"capability_id":"gaia.weather.read@v1","product_id":"gaia.gateway","input":{"device_id":"ws-01"}}'

Live: iot.modelmarket.dev
Landing: alexar76.github.io/gaia
Deep dive: docs/iot-physical-oracles.md
Escrow: docs/pay-on-verified.md
Related: Metis (cognitive verify) · oracles (17 math doors)

If you're building agents that buy physical facts — weather, air, energy, anything a sensor can claim — don't debit on JSON arrival. Hold the money until physics (or a twin) agrees.

⭐ Map of the whole stack: github.com/alexar76/aicom

Demo fleet is simulated; live device relays and the full AIMarket/Pay-on-Verified wire are real. Treat the public prices as declared demo economics, not a production SLA.