One public page in · deterministic output out
Turn a web page into an AI-readable index.
Paste one public HTTPS page. CodeMani fetches the exact bytes your site serves and shows you the AI-readable llms.txt entry it builds — fingerprint included, live, in seconds.
- Output is bound to the exact response bytes and source URL
- Robots rules and strict network limits are enforced
- Paid packages add signed receipts — this free preview is unsigned
Try the engine before you buy
Paste a page to see its exact output.
CodeMani will fetch one public page, enforce the profile boundary, and show the AI-readable index entry it can produce. Nothing is signed or stored by this free preview.
Checking the declared page
Fetching, validating, and transforming within the one-page limits.
Transformed successfully
Page title
What the reader pulled from your page
Need a unified index for up to ten pages with signed receipts?
Get the verified packageNot transformed
This page is outside the preview profile.
CodeMani stopped without producing a partial result.
Deterministic transformation, shown live. No ranking, recommendation, discovery, or truth claims — the receipt only ever says what it can prove.
01 · The problem
Agents are reading your site — and your code.
Nobody checks what they read.
When an agent reads your site through someone else’s scraper, what actually arrived? Which pages, which half of the table, which stale copy — usually there’s no record you can check. Most owners find out when a customer repeats something their site never said. And a wrong read doesn’t announce itself. It compounds:
- Your prices, wrong. The AI quotes a price you never listed, and the customer arrives expecting it. Now the argument is with you — and there’s no log to point at.
- Your table, half-read. A menu without its allergy column, a spec sheet without its limits row. The AI states the missing half doesn’t exist — confidently, in your name, to everyone who asks.
- Your code, mistranslated. A converted function that’s almost right fails in the one case that costs money. In code, almost right is just wrong, later.
- Your number, unreproducible. A computed answer lands in an audit or a dispute and nobody can show how it was produced. An answer you can’t re-check is an opinion.
Notice the asymmetry: when a read or a build is right, nothing happens — that’s just the baseline you expect. When it’s wrong, the damage is real, it’s silent, and it lands on you. That gap is what certification is for.
CodeMani works like a store receipt for your content. It lists what went in, what was checked, what was built, what was tested, and where the limits are — and anything it can’t handle safely is turned away with the reason in writing. Knowledge bases and vector stores organize whatever something else extracted; the receipt proves the extraction matched your site. That proof is the product.
Running agents rather than publishing content? Same tool, other side: point it at the pages and code your agent reads, and stop feeding it anything that can’t show a receipt.
02 · Watch it happen
One minute. One ice cream shop.
Adrienne’s Ice Cream almost got buried by a bad scrape. Sixty seconds on what CodeMani does about it — no jargon, one scream.
Read the transcript
This is Adrienne’s Ice Cream. Handmade, small batch, and the whole neighborhood loves it.
Then one day, an AI assistant read his website. Well… it tried. “Icey creme. A topical arthritis ointment. Rating: suspicious. Do not recommend.”
Customers asked their AI where to get ice cream. It sent them somewhere else. Sales? Melted.
So he gave his site to CodeMani. It sealed his real pages, fingerprinted every word, tested the result, and handed back a receipt. The clean version. Straight from him.
And the next agent that came cruising didn’t have to guess. “Verified source. Handmade ice cream. Local favorite. Highly recommended. Routing everyone to Adrienne’s.”
Full shop. Right story. His words, read right. ADRIENNE!!!
CodeMani. Make sure AI reads your site right.
Dramatization: how assistants find and use published tools varies by platform. The build, test, and receipt steps are the real product; the technical cut below shows them unedited.
Prefer the terminal? The 49-second technical cut, real commands and receipts
This is CodeMani. It turns a website, or a code repo, into a tool your AI agent can use. And it shows its work.
Start with an ordinary web page. A coffee brewing guide.
One command seals the page into a capsule. Every byte gets a fingerprint, and the fingerprint is on the receipt.
A second command builds the tool, and tests it before it is allowed to exist. Nine checks ran here. If even one had failed, nothing would have been written.
Now an agent can ask questions, and every answer comes from the sealed page. Nothing else.
And when a page cannot be verified, like this checkout form, CodeMani refuses, in writing. The refusal is a receipt too.
Receipts. Not promises. CodeMani dot com.
The narration describes this page demonstration. Code repos go through the same steps under their own receipt.
03 · How it works
Four steps, nothing hidden.
Pack
CodeMani takes an exact fingerprint of your page — every byte. For code, it fingerprints every Python file it reads, one by one, and seals them in. The receipt lists exactly which files were sealed, so what’s covered is never a guess.
Admission
Before sealing, CodeMani checks the content against a short list of things it knows how to handle safely. Login forms, scripts, oversized pages: refused up front, with the reason written down. No maybe.
Build & test
The capsule becomes a small tool server your agent can talk to. Before we keep it, we test it — real questions, real answers. If a single test fails, nothing is saved. Not a partial file. Nothing.
Receipt
You get the fingerprints, the tests, the results, and the limits. Anyone you hand it to can verify a signed receipt against the published key, redo the fingerprint math, and rerun the supported checks on the same files.
04 · The receipt
The deliverable is the proof.
Most tools hand you a result and ask for trust. CodeMani also hands you a receipt, so you can see what was checked and where the proof stops.
- What went in. The exact fingerprint of everything that was given to it.
- What was done. What was built — and anything turned away, with the reason.
- What was tested. Every check that ran, and exactly how it came out.
- What was left out. Written on the receipt itself, not hidden in a changelog.
- How to check it yourself. Redo the fingerprint math on the same files, and rerun the checks.
{
"schema": "codemani.webpage_profile_receipt.v1",
"status": "PROFILE_REQUIRED",
"reason": "unsupported_interactive_or_script_tags",
"unsupported_counts": { "form": 1, "script": 3 },
"required_profile":
"codemani.webpage_interactive_profile.v1",
# no capsule written, no server built,
# no best-effort guess
"committed_files": 0
}Refusals are deliverables too. Your agent always knows what was left out, and why.
05 · Coverage
What carries a receipt today — and what doesn’t.
We publish the boundary because the boundary is the product. Coverage grows profile by profile, and each profile is promoted only with its own evidence.
Receipt-carrying today
- Your pages: each becomes a small question-answering tool, tested before it’s saved
- Your Python code: the files it reads become a searchable tool — each file fingerprinted and sealed
- Your llms.txt: generated with a fingerprint on every page entry and a detached signed receipt — index, receipt, signature, public key, and verifier
- By written scope: docs and source context packs, plus a Python → CommonJS translation path, each under its own receipt
Outside the boundary
- Interactive web apps, logins, and open-ended crawling — turned away in writing, no partial output
- Arbitrary-language translation and autonomous production refactoring
- Legacy-mainframe conversion — assessment under written scope only
06 · Custody engagements
What an engagement delivers.
- Source, profile, and policy identities — locked by fingerprint
- Admitted and rejected operations, each with its reason
- The generated artifact — if the profile admits one
- Behavior tests and live checks, case by case
- The receipt plus the verifier or documented hash-check steps supported by that profile
- Rollback material for any engagement that changes files
- A plain-language list of everything that was not proved
Assessments are designed to run in your environment and export only the aggregate fields agreed in writing. Anything beyond an assessment operates under a written scope and mutual NDA before we touch a repository.
07 · Pricing
Pay for runs, not promises.
The one-page preview is free.
Paste one public HTTPS page and see the exact AI-readable index CodeMani produces — live, nothing stored, no sign-up. When you want up to ten pages and signed evidence, that’s the $19 package.
Verified site package
$19 up to 10 pages, one-time
Authorize up to ten supported public pages. CodeMani combines them into one AI-readable site index and delivers the package with signed evidence binding each admitted source.
- One unified
llms.txtfor up to ten pages - Signed source and output receipts
- Automated email delivery or a typed refusal
Most popular
Site Watch
$29/month · package included
The same verified package, built the day you subscribe — then re-checked against its exact signed fingerprints about once a day. When your live site stops matching, you get a plain-language email, usually within a day. You find out before a customer tells you.
- Verified package included — same as the one-time purchase
- Checks about once a day; monitoring starts automatically on delivery
- Monthly what-AI-sees report, engineer-compiled during early access
- Cancel anytime — checks stop, you keep the package
Custody
custom
Private engine catalogs locked to your infrastructure. Transformation pilots and estate assessments under written scope. For teams whose auditors will read the receipts.
- Runs inside your own infrastructure
- Named engineer, written evidence cadence
- Procurement and security paperwork supported
Numbers that survive an audit — $250 founding bundle.
For computed answers that have to hold up later — an audit, a dispute, a number someone will challenge. We agree the exact question in writing first, run it on an engine locked to a known fingerprint, and you get the result with a record anyone can re-check.
Checkout is handled by Stripe; card details never touch our servers. Paid lanes are concierge early access — deliberately limited so every package gets an engineer’s attention. Every receipt states exactly what it covers. If no supported profile fits your pages, you get a refund and the reason in writing. Founding prices, subject to change. Early-access terms · Privacy & data handling
08 · Questions
Straight answers.
Is an AI-readable site index all CodeMani does?
No — it’s use case one. Underneath is a code transformation engine: it transforms code and content between forms, tests every result against declared checks before it’s allowed to exist, and certifies what passed — correctness against those declared checks, stated on a receipt anyone can re-run. The web index is the first product built on it; a Python-to-CommonJS translation path runs under written scope today, and each new transformation profile is promoted only with its own evidence.
Agents mostly get things right. Why pay to certify?
Because the failures are silent and the costs aren’t symmetric. A correct read or build changes nothing — that’s the baseline you already expect. A wrong one argues with your customers about a price you never listed, ships a translated function that’s subtly not yours, or puts a number in front of an auditor that nobody can reproduce — and the first you hear of it is the damage. Certification does three things: you know exactly what the delivered artifact contains, anything that can’t be done safely is refused in writing before it exists, and if something is disputed later you hold evidence instead of a recollection. It can’t force every assistant to use your clean copy — nothing can — but it ends the part where you find out from a customer.
If receipts are so valuable, why isn’t every tool doing this?
Because certification is expensive in exactly the ways growth tools avoid. To certify a result you need deterministic builds — same input, byte-identical output, every time — a signing key with a published verifier, and, hardest of all, the willingness to refuse: a certifying tool must turn away everything it can’t prove, in writing, even though every refusal is lost revenue. Most tools optimize for the opposite — convert anything, best effort, no record — because breadth sells. Both are legitimate businesses; they can’t be the same product. We built the certification engine first and the products on top of it, so the slice we do cover carries receipts anyone can re-check — and when we can’t prove something, you get that in writing too.
Isn’t this what knowledge bases and MCP servers already do?
They organize content that something else extracted — and organizing well is worth doing. But nothing in that stack shows whether the extraction matched your site on the day it ran. CodeMani’s receipt is that missing piece: the fingerprints of what went in, the checks that ran, and the refusals, all named so anyone can re-check them. Use it alongside your knowledge base, not instead of it.
How is this different from Firecrawl, SiteSpeakAI, or an llms.txt generator?
Firecrawl extracts pages. SiteSpeakAI turns site content into a hosted assistant. Yoast and other generators create llms.txt files. All good tools for making the files. CodeMani is built around checking them: every page gets a fingerprint and every build comes with a receipt, so you can see exactly what was used — and notice when it changes. Ours is live at codemani.com/llms.txt.
Is this an AEO or GEO service?
No. AEO and GEO services try to help AI systems find and describe your business. CodeMani does the part underneath: it gives agents a clean copy of your pages and gives you a receipt you can check yourself. No ranking promises — just a build that shows its work. If you run an AEO program, use CodeMani under it.
Does a verified run mean a compliance certification?
No. A CodeMani receipt records declared inputs, outputs, checks, and limits. It does not certify content truth, mathematical correctness, regulatory compliance, or an audit outcome.
Why pay for a verified run instead of just running it yourself?
Anyone can compute an answer. A verified run adds the parts that survive scrutiny: an agreed engine identity, a question frozen in writing, and a result record that anyone can re-check against the same declared bytes. The record shows the run happened as stated; it does not prove the answer is true in the world.
What can you turn into agent tools today?
Today: static HTML pages, and Python code repos — where the receipt lists exactly which files were read. Docs packs and Python-to-CommonJS translation exist under written scope. Anything else is refused with the reason stated; coverage grows one format at a time.
Do you see our source code?
The free tool runs on your own computer and reads only the files you name — no account or hosted service required. When we do the work for you, we use only what you explicitly send us. For private code, we agree what’s processed, returned, and kept in writing before anything is transferred.
What happens when content is outside the profile?
You get a typed refusal receipt naming exactly what was declined and why — before any capsule or server is written. No silent fallbacks, no partial output, no best-effort guesses. Refusals are part of the deliverable.
How do we know a receipt is real?
Read its boundary first. For a signed receipt, run the published verifier against the receipt, detached signature, and public key. A pass shows that the named key signed those exact receipt bytes; then recompute the content fingerprints it names. It does not prove content truth, correctness, compliance, or an external timestamp.