Take the power over your data back.
A GitChain is a smart container — it carries its own knowledge, its own agent, its own proof of integrity. Truth context for LLMs, sealed once, verifiable forever. OCP is the wire format that carries it; Neo is the viewer that turns it into work.
Not a promise. A protocol you can hold — verifiable by anyone, anytime.
One container. One protocol. One viewer.
GitChain is the brand. Underneath it sits a sealed container with a resident agent, an open wire format that carries it, and a specialised viewer that turns it into work. Each piece stands on its own — together they make truth context the default.
A smart container with agent.
Sealed knowledge, resident agent, signed by the issuer, anchored on Base mainnet. Anyone can hold it. Anyone can verify it. Nobody can tamper with it.
OCP — Object Context Protocol.
GitChain's wire format. Three primitives — identity, activate, invoke. Rule-based, clean, truth context. The LLM receives only what the container allows.
Neo — your container, in chat.
The specialised, multi-tenant chat workspace that turns any container into a working surface. Cite the source, audit the trail, never hallucinate.
One sealed object. Carried by a protocol. Shown by a viewer.
GitChain is a single signed artifact at the bottom — knowledge, rules, proof of integrity, all in one. OCP is the wire format that carries it across the network with the truth contract attached. Neo is the polished surface that turns it into work for humans. Three layers, one architecture, one design language.
Knowledge today is unsealed, unsigned, unsourced.
The thing you are about to ship to a model — a manual, a regulation, a clinical study, a tax brief, a mandate file — is plain text in a folder. No sender. No seal. No proof of integrity. No rule-set governing who can use it for what. That is the default state of knowledge in software today, and it is the reason every LLM that touches it can plausibly lie about it.
Documents are loose.
A GitChain is a single signed artifact — five named files, hashed in canonical order, anchored on chain. Anyone can verify that the bundle they hold is exactly what the issuer sealed.
Models hallucinate when sources are vague.
A GitChain answer comes back with the exact atom, the exact source, the exact offset. The model is bound by the protocol to quote only what came back. The math doesn't move.
Sharing knowledge means losing control over it.
The container's resident agent decides what each consumer sees, in what shape, for what purpose. Issuer policy is enforced from inside the artifact, not by the platform on top of it.
Four steps. Sealed once. Verifiable forever.
Every GitChain follows the same simple flow — from raw knowledge to a sealed object that any third party can independently verify. The four steps are not best practice; they are mechanically enforced by the protocol.
Start with a body of knowledge — a product datasheet, a legal mandate, a clinical study. Extract it into atoms (paragraphs, claims, facts), add the agent that decides who reads what.
The atoms are hashed in canonical order, the merkle root is computed deterministically, and the issuer signs the root with their Ed25519 key. The container becomes a single signed artifact.
The signature plus the merkle root are written to a public blockchain. From this moment on, the container's identity and integrity are independently verifiable forever.
Any third party — auditor, regulator, journalist, opposing counsel — can rebuild the container from its atoms and confirm the bytes match. Trust without a trust anchor.
The container is the object.
OCP — the Object Context Protocol — is both the sealed object and the wire format that carries it, fused into one signed artifact. The object holds its own knowledge, its own access rules and its own proof of integrity. The LLM receives only the truth — and is bound by the protocol to answer only from it. The container decides — not the platform, not the model, not us.
It is your data.
You decide who sees what — and for how long. Revoke any access at any time. Every read is logged. The container enforces the rules even when we are not in the room.
Knowledge that defends itself.
What today is scattered across SAP, PIM, DAM, CMS becomes one signed artifact. Customers, partners, regulators each see exactly what they are entitled to — no more, no less, with proof.
A protocol, not an app.
Sealed Merkle DAG, Ed25519 signed, anchored on Base. Capability-tier discovery via a resident agent. Local inference via Gemma 4 — nothing routed through a provider. Open spec, three primitives.
What is inside.
A container is not a file. It is an artifact that carries its own knowledge, its own index, its own access rules and its own proof of integrity — in five named parts.
atoms.cborEvery fact, paragraph, datapoint — addressable, hashable, immutable. Sorted canonically so two independent rebuilds produce the same bytes.
embeddings.tqPolarQuant b=3 + QJL signs — 384 bytes per vector instead of 4096. The container ships its own index. No vector-DB provider, no hidden tier-0 consumer.
agent.jsonCapability blueprints, license tiers, issuer policy. The container is its own API surface — signed, versioned, enforced from inside.
echo.jsonCitations, retrieval traces, every answer linked back to source atoms. Hallucination becomes structurally visible — and refusable.
container.jsonkeccak256 over the canonical leaf set, Ed25519 signed by the issuer, on-chain anchored. Tampering costs cryptography to forge — not just trust.
Three components. Nothing leaves the room.
Sovereignty without these three is rhetorical. Together they make a container fully self-contained: compressed enough to seal, deterministic enough to verify, served by a model that runs on your hardware — never a provider's.
Compression that ships.
PolarQuant b=3 + QJL signs. Embeddings collapse from 4 KB to 384 B per vector — small enough that the index lives inside the container. No vector-DB provider sits between you and your knowledge.
Read the TurboQuant paper ↗Determinism that verifies.
Same atoms in, byte-identical embeddings out. Layer-3 full rebuild matches the sealed bundle to the bit — anyone can audit a container without trusting us. Reproducibility is not an aspiration; it is a property.
How determinism is enforced ↗Inference that does not leak.
Ungated, on-premise, no API. Queries do not pass through OpenAI, Anthropic or Google. The container responds with proof, the model responds with text, and tcpdump shows zero traffic to anyone outside the host.
On-prem inference architecture ↗
Anywhere sovereignty, scope and proof matter.
The protocol is industry-agnostic. Wherever a clear data sovereign exists, multiple consumers need scoped views, and later proof is required — OCP fits. No bespoke integration. No vendor lock-in. The container is the contract.
One protocol. Six verticals shown. The list keeps growing — that is the point.
First contact, then capability.
Every consumer interaction with a container starts the same way — a question of identity. The container introduces itself, lists what it can do, and decides — based on the license at the door — what each consumer is allowed to see. The same primitives play out differently across industries.
Then it plays out — by industry.
Five tableaus. Same protocol underneath. The container is always the contract.
Manufacturers
Law firms
Auditors
Clinical research
Academic research
The architecture, in action.
Below is a research showcase — a single container we sealed and anchored to demonstrate the protocol end-to-end. It is not a customer deployment. It is the system proving itself in the open.
An industrial product as a sovereign container.
We took a single industrial product, extracted every datasheet, installation manual and certification page, and sealed it as one OCP container. Three lanes — text retrieval, vision retrieval, out-of-scope trap — all answered by a local model with citations back to source atoms. The Merkle root is anchored on Base mainnet, the embeddings are deterministic, and Layer 3 full rebuild verifies the bundle byte-identically.
Layer 3 verification — three independent rebuilds, one Merkle root. Reproducibility as a property, not a hope.
Read deeper.
The protocol is open. The math is published. The reference implementation is on GitLab. Take it apart. Rebuild it. Audit it.
The wire-level protocol: identity, activate, invoke. Capability blueprints, issuer policy, license tokens.
atoms.cbor, embeddings.tq, agent.json, echo.json, container.json — canonical leaf order, Merkle hashing, sealing rules.
11× compression at retrieval-quality parity. Bit-packed 384 B per vector. Deterministic encoding for Layer-3 verification.
Five integrity ops, sealed-bundle byte audit, full-rebuild reproducibility. Trust without a trust anchor.
On-premise serving, b=4 KV-cache compression, zero outbound traffic, end-to-end sovereignty in one host.
Monorepo. Promote-worker (11 stages), packages/qjl (TurboQuant), apps/service (anchor + license), packages/ocp-server.
OCP is not a product.
It is a layer.
We do not host your knowledge. We do not see your data. We are not in the loop when your container speaks. What we publish is a protocol — and a reference implementation that proves the protocol holds.
Sovereignty is not a feature toggle. It is a property of the system — cryptographic, deterministic, on-chain. We are giving the power back.
Pick your depth.
Open the live research demo and ask the container a question. Verify the answer on chain in one click.
Wire-level protocol, container format, Trinity architecture. Open spec, reference implementation, no NDA.
If your organisation has knowledge that needs sovereignty — products, cases, dossiers, datasets — we are interested in piloting.
Sealed truth, signed, on-chain. The smart container with agent — for verified context. By GitChain GmbH.
Anchor contract on Base ↗