Loading TACITUS
Loading TACITUS
The Context Capsule
Serious knowledge work runs on more than prose: sources with provenance, claims with degrees of trust, time that doesn’t lie, and — the part nobody else captures — expert reasoning itself: heuristics, mental models, traps, house style, output contracts.
A Context Capsule packages all of it in one portable, inspectable file that any compatible AI workflow can use — and any human can audit.
One structure · four types
Four capsule types, one internal anatomy. Each card links to a real example file — not a mockup.
Who you work as: role, mandate, audience, voice, standing positions.
Built from: A conversation plus your past documents.
example .jsonWhat is going on: actors, claims, events, contradictions, episodes.
Built from: Your documents, feeds, and a guided interview.
example .jsonHow an expert thinks: methods, heuristics, traps, checklists, devices.
Built from: An expert-elicitation interview.
example .jsonWhat good looks like: format, structure, citation style, register.
Built from: Exemplar documents and a contract.
example .jsonThe shared anatomy — nine layers, every capsule
One real example file per type, compiled by the engine and rendered here from the actual JSON — manifest, seal, and every section the bundle carries. Download any of them and look inside.
loading example…
Every claim binds to a source span with a hash and a trust tier. Disputed claims must surface as disputed.
What happened and when you learned it are tracked separately — bi-temporal honesty, so analysis never rewrites its own past.
Nothing is promoted into a capsule without an explicit reviewer decision — approvals, rejections, and caveats are part of the object.
Each capsule ships an embedded, queryable graph of its actors, claims, and episodes. No external database required.
On the spec roadmap: an integrity envelope — Merkle root over the bundle, Ed25519 signatures, and a one-line capsule verify. Until it ships, this page says so plainly; we don’t claim signatures we haven’t shipped.
A capsule is not retrieval fodder — it is a guided reasoning substrate. Ontology, graph, reasoning, and contract work together so the model’s freedom is spent on judgment, not on inventing structure. Here is what the agent actually receives, layer by layer:
The ontology binds every entity and relation to the kernel grammar plus the capsule’s own semantic extensions. “Commitment” is not a vibe — it is a class with required fields, invariants, and a place in the graph. The model reasons over types, not over prose it must re-parse.
ontology_slice · cores: ["aco", "conflict_analysis"] · 8 primitives + domain termsActors, claims, episodes, and their typed edges — each carrying confidence, temporal scope, review state, and source spans. Multi-hop questions are traversals of structure, not chains of guesses.
graph.jsonld + capsule.lbug · MATCH (a)-[e]->(b) WHERE e.review_state = "approved"Reasoning devices are executable method: named procedures with required primitives, ordered steps, and critique prompts. Traps are failure modes with detection questions. The agent doesn’t imitate an expert’s style — it runs the expert’s checklist, attributably.
devices[].procedure · traps[].detection_prompt · heuristics[]The runtime layer is binding: assert T1, attribute T2, hedge T3; cite every claim; surface every dispute; follow the output contract’s structure and register. Auditability is not a feature on top — it is the exit condition.
trust_rules: {T1: assert, T2: attribute, T3: hedge} · must_cite: trueThe deeper claim · capturing how experts — and philosophers — think
The four types divide the world the way thinking actually divides: situations (what is the case), intellectual tools (how to interrogate it), identities (who is asking, with what mandate), and knowledge products (what a defensible answer looks like). That taxonomy is old — it is how methodologists, analysts, and philosophers have always organized inquiry. Capsules make it machine-operable.
So a Tool capsule can hold a dialectical method as readily as a mediator’s checklist: thesis interrogated by antithesis, assumptions surfaced before evidence is weighed, the steelman required before the rebuttal. Package a school of thought’s devices — a Socratic question battery, an ACH matrix, a falsificationist test sequence — and any agent that attaches it reasons in that tradition, visibly, with the margin naming which device shaped which judgment. Context, abstracted knowledge, and method stop being what the model vaguely absorbed in training and become what it demonstrably applied.
Capsules aren’t authored from a blank page. They precipitate out of doing the work — in PRAXIS, our workbench, or in your own tooling via the open format.
Conversationally: an assistant interviews you, ingests your documents, proposes structure. You review and promote.
Compose capsules onto your workspace: who you are, what is happening, how your experts think, what good output looks like.
Generation that is cited, contract-bound, and inspectable — the margin names the heuristic that shaped each judgment.
Human gates decide what gets promoted. Capsules version, diff, and travel — privately, in your org, or in the open.
The capsule engine is DIALECTICA — an open-source Rust workspace: a six-stage pipeline where models propose and humans decide, a deterministic compiler, 24 published JSON Schemas, a CLI, and an MCP server any agent can call.
Evidence, claims, situation, temporal, ontology, reasoning, memory, governance, runtime — each with its own mutability contract, in one JSON-LD document.
Every capsule ships a read-only Ladybug projection (capsule.lbug), queryable with Cypher, digest-pinned to the semantic layer — no server required.
Eight practitioner primitives as the stable grammar; per-capsule ontology blueprints proposed by models and promoted by humans.
Public capsules free and open; private registries for institutions; every capsule signed, versioned, and attributed. What package registries did for code, the Capsule Registry does for verified knowledge.