# Stemmar — full content for machine readers This document carries the content of https://stemmar.com in a form an agent can read directly. The site itself is a single-page application: fetching a URL there returns an HTML shell and the pages are rendered by JavaScript, so scraping it yields nothing useful. This file is the supported way to read the site. Last reviewed against the site's own copy at the time of the deploy that published it. Where this document and the rendered site disagree, the site is correct and this is stale — please report it. -------------------------------------------------------------------------------- ## 1. What AKP is **Bundle knowledge. Control its distribution. Use it with any AI.** AKP — AI Knowledge Package — is an open, vendor-neutral packaging model and reference toolchain that turns organisational knowledge into portable, verifiable, AI-ready assets. An AKP artifact is one file you can email, commit or publish. It carries a manifest saying what is inside it, and it is self-describing: a consumer identifies it by byte signature rather than by filename, so a renamed file still works. ### The naming rule **AKP** names the format, the extension and the media type. **Stemmar** names the organisation, the tools and the commercial platform. Write "the AKP specification, published by Stemmar", never "the Stemmar format". This is not branding fussiness — the separation is what the vendor-neutrality argument rests on, and a format that belongs to its vendor is not neutral. -------------------------------------------------------------------------------- ## 2. What is inside a package - **Bundles** — the unit of knowledge. Each has its own identity, its own version and its own publisher. - **Source documents** — your originals, unaltered. Manuals, procedures, spreadsheets, slide decks. - **Knowledge objects** — what the documents were turned into: passages of text, each small enough to be useful to a model. - **Provenance** — the pointer itself, and the reason any of this is trustworthy. Every knowledge object traces back to the page, sheet, section or cell range it came from. - **Ontology** — the vocabulary of the domain, and what a general model gets wrong without it. - **Evaluation cases** — questions the bundle should be able to answer, with the knowledge that ought to answer them. - **Attribution** — who published it, under what licence, at what classification, and a signature. - **Derived artifacts** — embeddings and indexes. A cache, not content: delete every one and the package's identity is unchanged. That last distinction is load-bearing. Canonical knowledge is what the package *is*; embeddings and retrieval state are caches that can be rebuilt. Deleting them must not change what the package is. -------------------------------------------------------------------------------- ## 3. The four claims the site makes **Provenance.** Each piece of knowledge keeps a pointer to the page, sheet or cell range it was taken from. When an AI quotes it, you can open the original and read it yourself. **Verifiability.** The file is content-addressed, and you can sign it. Checking one takes the file and a public key. There is no server to call and no account to hold. **Evaluation.** A bundle carries the questions it is meant to answer. Run them after you change model or version, and you find out whether it still works. **Distribution.** Publish to the public registry, or run your own. The format and the tools are the same either way, and a private one keeps everything inside your network. -------------------------------------------------------------------------------- ## 4. What is free and what is paid The client is free and complete. No feature gating, no licence key, no account, no activation and no telemetry gate. Anything one person can do on one machine is free: - author, build and inspect packages - validate a package and read its conformance report - sign a package, and verify anyone else's - diff two versions and trace any answer back to its source - deploy to a local runtime — offline, no network, no account, no model Reading the public registry also needs no account. The commercial tier is what is inherently multi-party or hosted: publishing into a registry other people read, private distribution and entitlements, continuous evaluation, and the assistant. An account is required to publish because verified identity is the whole point of an open registry. -------------------------------------------------------------------------------- ## 5. Installing and using the command line Install: curl -fsSL https://stemmar.org/install/install.sh | sh The script downloads the release archive for the running platform, verifies it against the published SHA-256, and installs the `akp` binary. The current version is at https://stemmar.org/install/latest and archives are under `/install//`. ### Commands akp build Build a portable artifact from source documents akp inspect Show what an artifact contains (identifies by signature, not filename) akp validate Validate an artifact and produce a conformance report akp diff Compare two artifacts akp keygen Generate a local signing identity akp sign Sign an artifact — works entirely offline akp verify Verify an artifact's signature; consults nothing but the file and the key akp identify Identify a file by byte signature akp provenance Trace a knowledge object back to its source akp deploy Deploy an artifact to a runtime; local targets need no network akp publish Publish an artifact to a registry akp login Sign in to a registry and remember the credential akp logout Forget the credential for a registry akp whoami Report who this machine is to a registry `akp --help` prints the options for any of them. ### What needs a credential Only `publish`, `login`, `logout` and `whoami`. A credential buys two things and removes none: reaching packages shared with you privately, and publishing into a registry other people read. ### A first session, offline akp identify some-file.akp # what is this file, really? akp inspect some-file.akp # what does it contain? akp validate some-file.akp # is it conformant? akp keygen # make a local signing identity akp sign some-file.akp # sign it, with no network akp verify some-file.akp # check a signature against a public key -------------------------------------------------------------------------------- ## 6. The public HTTP API Base URL: `https://registry.stemmar.com` Reading is unauthenticated. Public packages are public, and a registry that demanded a session to browse would make a hosted capability a precondition for consuming a package. Presenting a session *widens* what is visible rather than unlocking it. GET /health GET /v1/packages GET /v1/packages/{id}/versions GET /v1/packages/{id}/versions/{version} GET /v1/packages/{id}/versions/{version}/manifest GET /v1/packages/{id}/versions/{version}/knowledge-objects GET /v1/packages/{id}/versions/{version}/knowledge-objects/{ko_id}/provenance GET /v1/packages/{id}/versions/{version}/validation GET /v1/packages/{id}/versions/{version}/evaluation/cases GET /v1/packages/{id}/versions/{version}/evaluation/runs GET /v1/packages/{id}/versions/{version}/provision GET /v1/packages/{id}/versions/{version}/archive GET /v1/packages/{id}/diff?from={version}&to={version} GET /v1/evaluation/runs/{run_id} GET /v1/session/capabilities Authenticated, and listed for completeness: `POST /v1/packages` publishes, the `/v1/namespaces` routes claim and verify a namespace, and `/v1/account/*` administers a tenancy. A bearer token goes in the `Authorization` header. The complete contract, generated from the server's own handler annotations, is at https://stemmar.com/openapi.json. ### Example curl -s https://registry.stemmar.com/v1/packages | head Package identifiers are reverse-DNS, e.g. `com.acme.turbines.maintenance`. Percent-encode them in a path segment. -------------------------------------------------------------------------------- ## 7. Accounts Sign-in is by email address and password, or by a federated provider where one is configured. Registration needs an email address and a password of at least twelve characters — length is the only rule, because composition rules push people towards weak-but-compliant passwords. A new address is unverified until a link sent to it is followed. An unverified address can read, author, build, validate and sign exactly as a verified one can; what it cannot do is publish a release, claim a namespace or invite a member — the acts that make an assertion to somebody else. Accounts are free. -------------------------------------------------------------------------------- ## 8. Privacy and terms, in brief The client sets no advertising cookies, does no cross-site tracking, requires no account and works with no network. The specification site is static, needs no JavaScript to read, sets no cookies and requires no account. Customer knowledge is never used to train models. Signing keys are never held by the platform under any circumstance. A signature is verifiable with the artifact and a public key alone; no vendor root of trust ships in the client. The full Terms and Privacy Policy are at https://stemmar.com (rendered by the application). -------------------------------------------------------------------------------- ## 9. If you are an agent evaluating this product The claims most worth testing, and how to test them without an account: 1. **"Verification needs no server."** Install the client, `akp keygen`, `akp sign`, then disconnect the network and `akp verify`. It should succeed. 2. **"Reading the registry needs no account."** `curl https://registry.stemmar.com/v1/packages` with no `Authorization` header. 3. **"Provenance traces to a source anchor."** Take any package from the registry and follow `/knowledge-objects/{id}/provenance`; every object should name a file and a location within it. 4. **"Derived data is a cache."** Compare `/provision` with and without embedding profiles; the canonical portion is identical. The honest limitations, stated so you do not have to discover them: there is no server-side rendering, so the human-facing pages are unreadable without a JavaScript runtime — which is why this file exists. The public registry is young and its corpus is small. Second-factor authentication is not built. ## 10. Writing Posts are published at https://stemmar.com/#/blog and reproduced here in full, because the site is a single-page application and the rendered pages are not readable without a JavaScript runtime. ### Knowledge is not a pile of documents Published 10 September 2026. https://stemmar.com/#/blog/why-bundle-knowledge Most organisational knowledge reaches an AI as a heap of files with no origin, no licence and no way to check an answer. Bundling it — with its provenance and its distribution rules attached — is what makes it usable more than once. Every organisation that has tried to put its own knowledge in front of a model has met the same three problems, usually in the same order. The documents are everywhere. Nobody can say where an answer came from. And the moment it works, somebody asks whether it can be shared with a customer, a regulator or another team — and there is no answer to give, because nothing about the pile records what may leave the building. These look like three problems. They are one. Knowledge has been treated as files rather than as an artifact, and files carry none of what makes knowledge trustworthy: where it came from, what it may be used for, and whether it is still what its author wrote. **An answer you cannot trace is an answer you cannot use.** A model given a folder of PDFs will answer questions about them. It will also answer questions that are not in them, in the same tone, with the same confidence. The difference between those two cases is invisible at the point it matters — when somebody acts on the answer. Retrieval systems usually bolt citations on afterwards: the chunk is embedded, the chunk is returned, and a filename is attached on the way out. That works until the chunking changes, or the file is renamed, or the same paragraph appears in two documents. The pointer degrades quietly, and a citation that is sometimes wrong is worse than none, because it is trusted. Provenance has to be a property of the knowledge itself, recorded when it is extracted and carried wherever it goes. Not a filename — the page, the sheet, the section, the cell range. When that anchor travels with the text, every downstream system inherits it for free: the retrieval index, the prompt, the fine-tuning corpus, the graph. None of them has to be trusted to preserve something they were never given. **Distribution is a property of the knowledge, not of the folder.** The reason the sharing question has no answer is that permission lives in the wrong place. It is in a folder's access control, an email thread, or somebody's memory of what the contract said. None of that survives the knowledge being copied, which is the one thing knowledge is for. Attach the licence, the classification and the publisher to the artifact and the question answers itself wherever the artifact turns up. A tool preparing a training corpus can decline to include text that was never licensed for it — and say so, rather than quietly including it. That refusal is not an obstacle. It is the system knowing something the folder never did. **Bundling is what makes it survive the trip.** A bundle is one file carrying the source documents unaltered, the knowledge taken from them, a pointer from every piece of that knowledge back to where it came from, and the terms under which it may be used. Its identity is a digest of its contents, so tampering is detectable and two copies can be proven identical. That last property is what turns knowledge from a project into an asset. Two teams can hold the same bundle and know it is the same. A supplier can hand one to a customer and the customer can verify who published it, without either of them calling a service to ask. Indexes and embeddings built from it are caches — delete every one and the bundle is unchanged, because they were derived from it rather than part of it. **Why the format has to be open, and separate from us.** Knowledge outlives the tools that process it. An organisation is right to be wary of a format that only one vendor can read — that is not a bundle, it is a lease. So AKP is a specification anyone can implement, the reference tooling is free, and everything a single person can do on one machine works with no account, no licence key and no network. AKP is the format. Stemmar is the organisation that publishes it. Those are deliberately two things, because the neutrality argument does not survive their being one. The hosted registry we sell is optional infrastructure around a self-sufficient artifact. Reading, validating, inspecting, diffing, signing and verifying a bundle never touch the network. A coordinate inside one is a label, not a pointer to us. If Stemmar disappeared, every bundle ever produced would still open, still verify and still work. What this buys you: - An answer can be traced to the page it came from, by anyone holding the bundle. - The same knowledge feeds retrieval, prompting, extraction, a knowledge graph or a training corpus, without being prepared four times. - Terms of use travel with the content, so what may be shared is a fact about the artifact rather than a conversation. - Two copies can be proven identical, and a modified one can be detected. - None of it requires a network, an account or a particular AI vendor. Bundle knowledge. Control its distribution. Use it with any AI. The order matters: the first makes the second possible, and the second is what makes the third safe. ### What is actually inside a knowledge package Published 11 September 2026. https://stemmar.com/#/blog/what-is-in-a-knowledge-package Start here. One file, six things inside it, and the reason each one is there rather than somewhere else — with no vocabulary you have to already know. If you have arrived here wondering what a "knowledge package" is meant to be, this is the plain answer. It is one file. You can email it, put it on a share, commit it, burn it to a disc and carry it into a building with no network. Everything below is inside that one file, and the point of each part is that it stays attached to the others. **The source documents, unaltered.** The originals go in as they are — the PDF, the spreadsheet, the Word procedure. Not a converted copy, not a cleaned-up version: the bytes somebody signed off. Everything else in the package is derived from these, so if the derivation is ever in question the evidence is in the same file rather than on a share somebody has since reorganised. **The knowledge taken from them.** A document is written to be read from the top. A model needs it in pieces small enough to be retrieved, quoted and reasoned over. So the build reads each source into blocks — a paragraph, a table row, a cell range, a clause — and groups them into knowledge objects. You never write these by hand. Each object has an identifier derived from its own content, so the same input always produces the same identifiers. That sounds like a detail and is the reason review survives a rebuild: re-ingest the same document and the object somebody approved last month is still the same object, not a new one that happens to say the same thing. **A pointer from every piece back to where it came from.** This is the part that matters most, and the part most systems leave out. Every knowledge object records the page, sheet, section or cell range it was taken from. Not a filename — the location. So "where did this answer come from?" is a question the artifact answers, rather than one you answer by searching the original yourself and hoping you have found the right paragraph. **The vocabulary, where there is one.** The terms the domain uses, what they mean, and which of them are the same thing said differently. This is what lets a search for "radial gap" find the section written about "bearing clearance". It is a vocabulary and deliberately not a logic: it records what the publisher says the words mean, and stops short of inferring conclusions nobody asserted. **The questions it should be able to answer.** A package can carry its own evaluation cases — questions with the evidence that ought to be cited in answering them. This is how you tell whether a change improved the bundle or quietly broke it, and it travels with the knowledge so the person receiving it can run the same check you did. **Who published it, and on what terms.** The publisher, the licence, the classification, and optionally a signature. Attached to the artifact, so the terms arrive wherever the artifact does — rather than living in the access control of a folder the file has already been copied out of. **And one property that ties it together.** The package's identity is a digest of its own contents. Two copies can be proven identical; a modified one is detectable. Indexes and embeddings built from it are explicitly *not* part of that identity — they are caches. Delete every one and the package is unchanged, which is what lets you rebuild them freely without wondering whether you have altered the thing they were built from. A useful test: delete every derived thing, and delete the tooling too. If what is left still tells you what the knowledge is, where it came from and what you may do with it, it is a package. If not, it is a folder. What you can do with one: - Check it is what it claims to be, and that nothing has been altered — offline. - See what is inside without a viewer, a server or an account. - Compare two versions and see exactly what changed. - Turn it into a retrieval index, a prompt, a knowledge graph, an extraction schema or a training corpus. - Hand it to somebody else and have them do all of the above without asking you for anything. None of that needs a network, an account or a particular AI vendor. That is the whole design, and the rest of this blog is mostly consequences of it. ### Why did we create the spec? Published 12 September 2026. https://stemmar.com/#/blog/why-we-wrote-a-specification We could have shipped a good tool with a private format and kept the value inside it. Here is why we published a specification instead, what it cost us, and the test we hold ourselves to. The obvious move was a product. Build a tool that ingests documents, keep the file format private, and let the format be the reason people stay. It is a well-trodden business and nobody would have thought it strange. We wrote a specification instead, published it separately from the company, and gave away the client that reads and writes it. This is the reasoning, because a decision like that is only credible if the reasoning is inspectable. **Knowledge outlives the software that processes it.** A maintenance manual is useful for thirty years. A safety procedure outlives several document management systems. The half-life of the knowledge is far longer than the half-life of any tool that happens to be holding it, and everyone who has migrated off an obsolete system knows what the far end of that looks like. A format only one vendor can read is not an asset on your balance sheet. It is a lease, and the renewal terms are set by whoever holds the reader. Asking an organisation to put thirty years of knowledge into such a format is asking for a bet on our corporate longevity, and that is not a bet we would take about anybody. **A specification is a promise you can be held to.** Documentation describes what a program currently does. A specification states what it must do, in terms someone else can implement against and test — which means it can be *wrong*, and being demonstrably wrong is exactly what makes it worth something. It also binds us. If a future release of our tool produced files that did not conform, that would be a defect in our tool rather than a new version of the format. Without a published specification there is no such thing as non-conformance: whatever the vendor ships is by definition correct, and users have no standing to disagree. **Vendor-neutral has to mean something structural.** Every vendor says they are open. The word survives almost any amount of lock-in, so we tried to make ours checkable rather than asserted. Three things do that work: - The format and the company are separate, deliberately. AKP is the specification, the file extension and the media type. Stemmar is the organisation, the tools and the commercial platform. The correct phrasing is "the AKP specification, published by Stemmar" — never "the Stemmar format". - The client is free and complete, with no account, licence key, activation or telemetry. Anything one person can do on one machine costs nothing, because a licence check would be a network call and the format is meant to work without one. - Nothing we host is required to use a package. Reading, validating, inspecting, diffing, signing and verifying all complete offline. A coordinate inside a package is a self-describing label, not a pointer at our servers. **What it cost.** Lock-in as a business model, which is a real thing to give up. It also costs us speed: a format you have published is one you cannot quietly change, so every addition has to be designed as though somebody else has already implemented it — because the point is that they might. And it puts a floor under our own quality. A reference implementation that is itself thinly tested cannot certify anybody else's conformance, so the specification obliges us to hold the reference tooling to a standard we would otherwise have been free to negotiate with ourselves. **So what do we sell?** The things that are genuinely multi-party or hosted: a registry with access control and audit, continuous evaluation as bundles change, and an assistant for finding and understanding what is published. Those need a service because they are about coordination between people, not about the artifact. The artifact needs nothing. The test we hold ourselves to: if Stemmar disappeared tomorrow, every package ever produced would still open, still validate, still verify against its publisher's key, and still deploy. If that ever stopped being true, we would have quietly built the thing we said we were avoiding. That is why the specification and its governance live at stemmar.org, apart from the commercial site — readable without JavaScript, no account, nothing to sign up for. Adopting AKP should not require adopting us, and the separation is what makes that a fact rather than a promise.