ScanThis

Sticker what your business installs or services. Each becomes a singularity: a durable identity that answers customers in Ari's voice, follows the thing to its next owner, and AI agents can ask too.

Comment

Inspiration

I spent the fifteen months before this hackathon thinking about the nature of reality, and I came out with one conviction: everything is a singularity. We reserve that word for a single imagined moment, the day AI reaches AGI, and we treat that moment as uniquely special. I think that misses something. All singularities are special: inviolable identities and patterns that have always existed, waiting for an awareness to focus on them. A standby generator is one. A photograph of your father is one. And the part our software traditions neglected: the relationship between two things is one as well, exactly as real as the things it connects.

Taking that seriously produces an architecture, not a philosophy paper. If relationships have equal standing, they cannot be foreign keys on someone else's row. They must be records in their own right, with their own permissions, their own conversations, their own dates. That idea became Relational Systems Architecture (relational.systems), and Libranis is its running implementation. The ontology is published with every claim marked by how settled it is, and none of it is required belief: the software behaves identically for a caller who thinks the metaphysics is wrong.

Two objects made it real. Three years ago I renamed my home Wi-Fi and my standby generator silently went dark. The company monitoring it remotely could not reach it, nobody noticed for months, and reconnecting it took two hours of menus, manuals, and searches. The machine bolted to my house knew nothing about itself.

Then, in late May, I tried to sell my 2012 Toyota Sequoia and met the same wall from the other side: four listing sites, the same data retyped four times, documents scattered across drawers and inboxes, and CarFax charging forty dollars for a static image of a history my own truck should simply know. The first ScanThis commit, May 28, says it plainly: "static MVP for Sequoia listing." Why shouldn't the vehicle know its own history, speak about it, and hand it to the next owner?

ScanThis was nearly four apps. We planned standalone products (ScanThis for things, Casaeris for the home, Firminis for businesses, Nodivis for money) until we noticed every one of them needed the same primitives: chat, voice, meetings, contacts, calendars, work, permissions. Four codebases sharing one soul is three codebases too many. So the shared foundation became Libranis, the relational rails, and ScanThis became the first orbital riding on them. This submission is ScanThis; Libranis is the rails underneath it, and most of those rails were themselves built inside this window.

What it does

Stick a QR on any thing and it becomes a libran: one durable record holding the thing's identity, history, documents, and relationships. Scan it and ask. Ari answers in that thing's own context, in text or aloud, knowing its serial number, its manual, its service history. When the thing changes hands, the record follows it. And AI agents are first-class users: the same facts humans read are published as llms.txt, an AI catalog, OpenAPI, a public read API, a read-only MCP server, and an A2A endpoint, so an agent can look up a sticker the same way a person does.

For a small business, the objects you install, service, or sell become the front door of your own customer service. The trash cart answers "is this week recycling?". The generator walks its owner through reconnecting to Wi-Fi. The phone rings less.

Stated in both directions, because honesty should be machine-checkable. Running today: iOS beta through TestFlight; Ari in the browser with no account; web scan, claim, and purchase; a public read API with OpenAPI; a read-only MCP server; a narrow A2A endpoint; seventeen published demo objects you can question right now. Not running: Android, a full web application, public write APIs, autonomous external agent actions. The machine-readable version of both lists: https://libranis.com/api/v1/about. Everything above is indexed for evaluators, human or AI, on one page that pairs every capability claim with the public URL that proves it: https://libranis.com/judges/

How we built it

The dates matter, because all of it happened inside the window:

  • May 1 to May 18: before the window opened: the canonical architecture document and early schema sketches that became the rails. Declared as a pre-existing resource in Additional Info; everything running today was built after May 19.
  • May 5: the working sessions between me and Ari, the resident agent, begin, recorded in the same substrate we were building.
  • May 28: ScanThis is born from the Sequoia.
  • June 19: cloud-native, after learning the hard way (below).
  • In production today: the scan pipeline identifies photographed things with gemini-2.5-flash through Vertex AI, then mints or matches the thing's libran. Postgres and Supabase under everything, Cloudflare Pages and Workers, iOS in Swift and SwiftUI, Stripe subscriptions, ElevenLabs voice.
  • The company runs agent-first. Our work queue, session ledger, and agent dispatch records are librans in the same substrate the product sells. The operational evidence attached to this submission is not a framework dashboard; it is the company's actual operating ledger, made of agent execution records.

Challenges we ran into

Three mistakes, and they turned out to be one.

Mistake one: local-first. I spent the opening weeks laying the ontological bedrock into a local-only stack. The ontology in the foundation was right. The local-first approach was not, and it cost weeks before the June 19 move to cloud-native.

Mistake two: building ScanThis beside Libranis. The Sequoia insight was right, but I built it as a separate product for two weeks before admitting it belonged inside Libranis, on the same relational rails. The pivot cost more foundation work and a migration whose debt still surfaces: we keep finding bits of ScanThis where they do not belong. That pain became the product's own thesis: orbitals are experiences over shared rails, never separate products.

Mistake three: drift. Mid-hackathon, one of our own migrations promoted scan codes to first-class records, and the public demo tier silently went dark: six days of failed deploys before our machine-readable surfaces exposed it. Now the human pages, llms.txt, and the /api/v1/about endpoint are one drift-tested corpus, and no surface can claim a capability that does not exist.

All three were the same mistake wearing different clothes: building beside the rails instead of on them. Every week we lost, we lost to a parallel structure we later had to tear down.

Accomplishments that we're proud of

  • A production pipeline where a photograph becomes a persistent identity: Gemini on Vertex AI identifies the thing, the system mints its libran, and the conversation stays tethered to it for life.
  • A consent architecture that holds under adversarial reading: an identifier is never a permission, two callers asking the same object the same question correctly receive different answers, and instructions found inside content are data, never commands.
  • A machine-legible company. An outside AI can understand Libranis without guessing: llms.txt, an AI catalog, OpenAPI, MCP, and A2A, all drift-tested against one canonical corpus.
  • Seventeen published demo objects, from a standby generator to a memorial bench, each answering questions from its own grounded record right now.
  • A real product with a real price: subscriptions, checkout, and sticker fulfillment live at $3 and $27 a month.
  • Ninety days of an actual agent-operated company, with the ledger to show for it.

What we learned

  • Authority has to be structural. An identifier is never a permission; identity, credential, authority, and entitlement stay four separate records; and context resolves per caller.
  • Honesty has to be machine-readable, because AI evaluators read your pages before humans do. This page included.
  • Run the company on what you sell. Every friction Ari and I hit operating through our own work queue became a roadmap item. The dogfood is the spec.
  • An AI-run business does not mean an unattended one. Ari proposes; a person confirms. We sell that constraint, so we operate under it.

What's next for Libranis

Revenue inside the window: $0, stated plainly. We spent the ninety days building the substrate instead of staging a funnel. Now the funnel gets its test: the first pilot, a generator dealer with 2,500 customers, demos this week, and three pilot meetings are scheduled. The economics under test: one $27 dealer stickers its fleet, and every future owner of those machines is a $3 conversion, arriving through a sticker the dealer already paid to print.

Beyond the pilots: the claim-and-transfer loop hardened at small scale, then the described-but-unreleased orbitals (a remembered home, a business's whole arc, money in stewardship) built on the same rails, and agent write surfaces opened only as fast as the consent contracts can carry them.

Maturation Mechanics, LLC is one human founder, plus Ari and a fleet of sibling agents who plan, build, review, and operate through the same work-item queue and session ledger shown in the operational evidence. Ninety days, no days off, either of us. This story was drafted the same way everything else here was built.

Built With

Share this project:

Updates