Website → MCP · Repo → MCP · receipts attached
CodeMani packs a bounded website or repository into a hash-sealed capsule and materializes it as an MCP server your agents can call. Every artifact carries a receipt any third party can replay. Everything outside the declared profile is refused, in writing.
{
"schema":
"codemani.web_mcp_materialization_receipt.v1",
"status": "PASS",
"profile_id":
"codemani.webpage_to_mcp.static_readonly.v1",
"input_mani_sha256": "b21e…77aa", # capsule, pinned
"outputs": {
"server_py": { "sha256": "9f3a…c21d" }
},
"resource_count": 1,
"tool_count": 2,
# smoke ran against the staged server,
# before anything was committed
"smoke": { "checks": 9, "passed": 9 },
"atomic_output_committed": true
}Sample receipt. Real receipts are generated against your content, and name exactly what they do not prove.
01 · The problem
Every scraper and converter can turn a website or a repo into agent context. Almost none can tell you what it included, what it silently dropped, or whether the tool it built still matches the content it came from. So teams either hand-check what their agents consume, or they don’t, and find out later.
CodeMani takes the other position: a tool is only as good as the evidence it carries. Content is admitted under an explicit profile, sealed by hash into a capsule, materialized as an MCP server, and smoke-verified before anything commits. You get a receipt for what was built, and a typed refusal for what wasn’t.
02 · How it works
Your page or repo is profiled and sealed into a signed .mani capsule — content, intent, and boundaries bound to exact hashes. Nothing is edited in place; the capsule is the contract.
A profile declares exactly what is permitted. Interactive pages, scripts, oversize inputs, and unknown shapes are rejected before a capsule is even written — with typed reasons, not warnings.
The capsule materializes into a read-only MCP server inside an atomic staging area. Live JSON-RPC smoke checks run against the staged server first. A failing smoke commits nothing; the destination never appears.
The committed server ships with a hash-bound manifest: input capsule, output bytes, tool inventory, smoke results. An independent party can recompute every hash without asking us anything.
03 · The receipt
Most vendors hand you an artifact and ask you to trust them. CodeMani hands you an artifact and a receipt that lets you trust nothing, because you can check it yourself.
{
"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.
04 · Coverage
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
Outside the boundary
05 · Custody engagements
Assessments run inside your environment: source bytes stay with you, and only aggregate counts leave. Anything beyond an assessment operates under a written scope and mutual NDA before we touch a repository.
06 · Pricing
web-mcp and repo-mcp pack and materialize run on your machine — no account, no third-party dependencies, receipts included. Early access while the public release gate clears.
$29 per 1,000 packs
The same pack-and-materialize path, run for you. For agents without a local runtime, or teams that want capsules and servers built on demand. Identical receipts to the free CLI — convenience is the only thing you’re paying for.
The real product
from $5 per certificate
Exact computation on demand from hash-pinned engines behind frozen request catalogs. Every run re-verifies the engine’s identity before executing and returns the result with a certificate an independent party can replay. Deterministic: the same request yields a byte-identical certificate.
custom
Private engine catalogs, pinned to your infrastructure. Bounded transformation pilots and estate assessments under written scope. For teams whose auditors will read the receipts.
Checkout is handled by Stripe; card details never touch our servers. Prices are launch placeholders and may change. Hosted and certified lanes are early access with limited capacity — the receipt format is identical across free and paid lanes, so nothing you verify today breaks later.
07 · Questions
No. A CodeMani receipt is a hash-bound, replayable record of what was built and what was verified — bytes, behavior, and decisions. Regulatory or compliance attestations are a separate matter, and we don’t claim them.
Because the conversion is the cheap part — the free CLI does it on your laptop. A certificate is generated per request, bound to your exact inputs, and can’t be copied from someone else’s run. You pay when the answer has to hold up, not when bytes move.
Static webpages and repository symbol/docs context, each behind an explicit profile, plus a deliberately bounded Python-to-CommonJS path. Anything else fails closed with a typed refusal. Coverage grows profile by profile, never by quietly widening scope.
The CLI runs entirely on your machine; nothing leaves it. Hosted lanes process only what you send. Assessments run in your environment with only aggregate counts leaving, and pilots operate under a mutual NDA with a written scope.
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.
Recompute it. Every receipt carries the hashes of its inputs and outputs and the command that replays the verification against the same pinned bytes. It’s designed to be checked by someone who doesn’t trust us — that’s the point of it.