{"canonical-stack-overview.section.detail-label":"How to read the route","canonical-stack-overview.section.footer":"One request · explicit handoffs · evidence returned","canonical-stack-overview.visual.title":"A representative request path","canonical-stack-overview.visual.subtitle":"The route changes with the work. The identity, contracts, and return path stay explicit.","canonical-stack-overview.visual.status":"Return path intact","canonical-stack-overview.visual.meta":"8-product suite + Kera","canonical-stack-overview.visual.footer":"Only the layers a request needs have to run. This view shows the complete path so every boundary can be inspected.","canonical-stack-overview.journey.aria":"Six-stage path through the Dweve stack","canonical-stack-overview.journey.return":"result + evidence return to the work surface","canonical-stack-overview.packet.input.label":"Enters at the edge","canonical-stack-overview.packet.input.consumer.title":"Question or file","canonical-stack-overview.packet.input.consumer.body":"Your request and the context you choose to share","canonical-stack-overview.packet.input.business.title":"Objective packet","canonical-stack-overview.packet.input.business.body":"Objective, sources, policy, and accountable owner","canonical-stack-overview.packet.input.technical.title":"Typed request","canonical-stack-overview.packet.input.technical.body":"Pinned context, constraints, and declared output","canonical-stack-overview.packet.output.label":"Returns to the edge","canonical-stack-overview.packet.output.consumer.title":"Answer and record","canonical-stack-overview.packet.output.consumer.body":"A useful result with the reasons and sources that support it","canonical-stack-overview.packet.output.business.title":"Result and evidence","canonical-stack-overview.packet.output.business.body":"Decision-ready output, owner, approvals, and record","canonical-stack-overview.packet.output.technical.title":"Result and receipts","canonical-stack-overview.packet.output.technical.body":"Typed output, weave trace, permits, and execution receipt","canonical-stack-overview.stage.work.role":"Work surface","canonical-stack-overview.stage.work.artifact":"durable work object","canonical-stack-overview.stage.knowledge.role":"Governed knowledge","canonical-stack-overview.stage.knowledge.artifact":"governed source set","canonical-stack-overview.stage.cognition.role":"Woven cognition","canonical-stack-overview.stage.cognition.artifact":"result + weave trace","canonical-stack-overview.stage.coordination.role":"Governed action","canonical-stack-overview.stage.coordination.artifact":"authorised task plan","canonical-stack-overview.stage.compute.role":"Compute","canonical-stack-overview.stage.compute.artifact":"executable plan","canonical-stack-overview.stage.placement.role":"Placement","canonical-stack-overview.stage.placement.artifact":"signed execution receipt","canonical-stack-overview.kera.label":"Separate foundation · when selected","canonical-stack-overview.kera.body":"graph-native language and toolchain","canonical-stack-overview.relationships.eyebrow":"Verified foundations","canonical-stack-overview.relationships.title":"The products do not hide what they depend on","canonical-stack-overview.relationships.boundary":"Only relationships asserted by the current product and open-source pages are drawn here. Absence from this ledger is not a claim that a foundation is unused.","canonical-stack-overview.relationships.built-on":"Built on","canonical-stack-overview.relationships.built-on-definition":"Inside the product or a real dependency of it.","canonical-stack-overview.relationships.works-with":"Works with","canonical-stack-overview.relationships.works-with-definition":"A supported integration, not an internal dependency.","canonical-stack-overview.relationships.research":"Research","canonical-stack-overview.relationships.independent-title":"Foundations with no product edge asserted in this view","canonical-stack-overview.relationships.independent-body":"Numerus, Signum, and Selvedge remain part of the 14 open-source routes. This ledger does not invent a product relationship where the current pages do not make one.","canonical-stack-overview.instrument.status":"Traceable","canonical-stack-overview.instrument.meta.scope":"Scope","canonical-stack-overview.instrument.meta.scope-value":"one request","canonical-stack-overview.instrument.meta.mode":"Route","canonical-stack-overview.instrument.meta.mode-value":"need-led","canonical-stack-overview.instrument.footer":"The route may shorten. The thread must not break.","canonical-stack-overview.instrument.row.identity.label":"Identity","canonical-stack-overview.instrument.row.boundary.label":"Boundary","canonical-stack-overview.instrument.row.return.label":"Return","canonical-stack-overview.instrument.consumer.title":"What stays attached","canonical-stack-overview.instrument.consumer.subtitle":"The answer should never become detached from the request.","canonical-stack-overview.instrument.consumer.identity":"Your question remains the thread through the run.","canonical-stack-overview.instrument.consumer.boundary":"Each handoff says what moves and what stays private.","canonical-stack-overview.instrument.consumer.return":"The result comes back with reasons and sources.","canonical-stack-overview.instrument.business.title":"The thread that stays intact","canonical-stack-overview.instrument.business.subtitle":"Accountability travels with the work.","canonical-stack-overview.instrument.business.identity":"The objective, owner, and source set retain one identity.","canonical-stack-overview.instrument.business.boundary":"Policy and approval gates remain named at every handoff.","canonical-stack-overview.instrument.business.return":"The result returns with evidence, decisions, and ownership.","canonical-stack-overview.instrument.technical.title":"The invariant through the run","canonical-stack-overview.instrument.technical.subtitle":"Contracts preserve identity across replaceable components.","canonical-stack-overview.instrument.technical.identity":"The request ID and pinned inputs follow every derived artifact.","canonical-stack-overview.instrument.technical.boundary":"Typed handoffs expose policy, execution, and placement decisions.","canonical-stack-overview.instrument.technical.return":"Trace and receipts join the typed result at the caller.","canonical-stack-overview.surface.stack.consumer.eyebrow":"The stack in motion","canonical-stack-overview.surface.stack.consumer.headline-lead":"One request keeps its identity","canonical-stack-overview.surface.stack.consumer.headline-accent":"from question to evidence","canonical-stack-overview.surface.stack.consumer.body":"The stack is easiest to understand as a journey. A question enters once, crosses only the boundaries it needs, and comes back with a result you can inspect. The labels keep product, foundation and research status separate before you choose a route.","canonical-stack-overview.surface.stack.consumer.detail-left":"The named stages show who owns knowledge, reasoning, action, compute and placement, so at every step you can see which owner answers and where the question stops if the later stages are never needed.","canonical-stack-overview.surface.stack.consumer.detail-right":"A request crosses only the boundaries it needs, so the full route is a map of what can happen rather than a promise that every product runs on every question, and the product, foundation and research labels stay separate as you read it.","canonical-stack-overview.surface.stack.business.eyebrow":"The stack in motion","canonical-stack-overview.surface.stack.business.headline-lead":"One request keeps its identity","canonical-stack-overview.surface.stack.business.headline-accent":"from objective to evidence","canonical-stack-overview.surface.stack.business.body":"The stack is one accountable operating path, not a catalogue of disconnected tools. An objective enters with its owner, sources, and policy, then returns as a result with evidence. That separation keeps the commercial scope legible while the route remains flexible.","canonical-stack-overview.surface.stack.business.detail-left":"Each product owns a distinct responsibility, so a team can adopt the layer that matches its operating need without taking on the whole path, and the boundary it buys stays legible in the commercial scope.","canonical-stack-overview.surface.stack.business.detail-right":"Only the required layers run, and explicit handoffs keep approvals, sources and execution records attached to the original objective, so the evidence returns with the result instead of being reassembled afterwards.","canonical-stack-overview.surface.stack.technical.eyebrow":"The stack in motion","canonical-stack-overview.surface.stack.technical.headline-lead":"One request keeps its identity","canonical-stack-overview.surface.stack.technical.headline-accent":"from typed input to receipts","canonical-stack-overview.surface.stack.technical.body":"Read the architecture as a request path. Typed input becomes governed context, a traceable result, an authorised plan, an executable plan, and a placement receipt. The route is descriptive: it records contracts and evidence, not a mandatory call graph.","canonical-stack-overview.surface.stack.technical.detail-left":"Named contracts keep components replaceable without hiding what each handoff accepts or emits, so a substitution stays reviewable and the schema at the boundary remains the thing actually under review.","canonical-stack-overview.surface.stack.technical.detail-right":"A route can skip unneeded responsibilities while preserving request identity, pinned inputs, permits and the return trace, so a shorter path is still a fully accounted one and every crossing it does make stays typed.","canonical-stack-overview.surface.products.consumer.eyebrow":"Why these products connect","canonical-stack-overview.surface.products.consumer.headline-lead":"Each product owns one part","canonical-stack-overview.surface.products.consumer.headline-accent":"of the same request","canonical-stack-overview.surface.products.consumer.body":"You can start with one product. When a request needs more, the products pass it forward without losing the question, sources, or record.","canonical-stack-overview.surface.products.consumer.detail-left":"The eight-product suite spans the work surface, knowledge, reasoning, governed action, compute, and placement. Each one owns a single part of the request, so you can start with the part you recognise and add the rest only when a request actually needs it.","canonical-stack-overview.surface.products.consumer.detail-right":"Kera is a separate systems foundation, selected only when that graph-native route is the right fit. It is not a ninth part of the suite, so you can read the eight products as one set and treat Kera as the route underneath, chosen for its own reasons.","canonical-stack-overview.surface.products.business.eyebrow":"Why these products form a stack","canonical-stack-overview.surface.products.business.headline-lead":"Each product owns one part","canonical-stack-overview.surface.products.business.headline-accent":"of the same run","canonical-stack-overview.surface.products.business.body":"Buy for the responsibility you need first. The suite can then connect work, governed knowledge, reasoning, coordination, compute, and placement without turning one operation into eight projects.","canonical-stack-overview.surface.products.business.detail-left":"The eight suite products can operate as one system, with each product carrying a named commercial responsibility. Buy the responsibility you need first and connect the rest later, so a first purchase stays scoped to one named owner rather than to the whole suite.","canonical-stack-overview.surface.products.business.detail-right":"Kera remains a separate systems language and toolchain, rather than a ninth component in the suite. It is selected when that graph-native route fits, and it is never a required step, so the licensed suite still counts eight products and nothing more.","canonical-stack-overview.surface.products.technical.eyebrow":"Why these products form a stack","canonical-stack-overview.surface.products.technical.headline-lead":"Each product owns one contract","canonical-stack-overview.surface.products.technical.headline-accent":"in the same request path","canonical-stack-overview.surface.products.technical.body":"The products divide responsibility without hiding the handoffs. Start at any contract boundary, adopt the components you need, and keep the caller-facing result inspectable.","canonical-stack-overview.surface.products.technical.detail-left":"The suite spans interface, knowledge, cognition, coordination, compute, and placement through named contracts. Each boundary is typed, so a component can be replaced without rewriting its neighbours.","canonical-stack-overview.surface.products.technical.detail-right":"Kera is a separate graph-native systems language and toolchain that participates only when selected. The request path does not require it, so the eight contracts hold without it and a route can be read end to end from the suite alone.","canonical-stack-overview.surface.see-it-work.consumer.eyebrow":"See the whole run","canonical-stack-overview.surface.see-it-work.consumer.headline-lead":"Watch the request move","canonical-stack-overview.surface.see-it-work.consumer.headline-accent":"then inspect what comes back","canonical-stack-overview.surface.see-it-work.consumer.body":"A useful demonstration should show more than the answer. Follow the request through the work it needs, then inspect the record returned with the result. The map below traces one request from the moment it is asked to the moment it comes back, naming what it read, what it decided, and what it left behind.","canonical-stack-overview.surface.see-it-work.consumer.detail-left":"The demonstration below follows one concrete run from request to result, so the visible artefacts have a clear origin.","canonical-stack-overview.surface.see-it-work.consumer.detail-right":"This wider map shows where sources, decisions, execution, and evidence sit around that run.","canonical-stack-overview.surface.see-it-work.business.eyebrow":"See the whole run","canonical-stack-overview.surface.see-it-work.business.headline-lead":"Watch the request move","canonical-stack-overview.surface.see-it-work.business.headline-accent":"then inspect what comes back","canonical-stack-overview.surface.see-it-work.business.body":"Do not judge the system from a polished answer alone. Follow the objective, owner, sources, policy, approvals, execution, and evidence as one accountable run. Each stage leaves an artefact you can name and an owner you can ask, and the map below shows where each one sits on the route your own request would take.","canonical-stack-overview.surface.see-it-work.business.detail-left":"The concrete demonstration zooms in on a single accountable route, with each artefact tied to the responsibility that produced it.","canonical-stack-overview.surface.see-it-work.business.detail-right":"Use the wider map to check what should return to the operating record and who owns that handoff.","canonical-stack-overview.surface.see-it-work.technical.eyebrow":"See the whole run","canonical-stack-overview.surface.see-it-work.technical.headline-lead":"Watch the request move","canonical-stack-overview.surface.see-it-work.technical.headline-accent":"then inspect every receipt","canonical-stack-overview.surface.see-it-work.technical.body":"A demo is only useful when the boundary artifacts are visible. Follow the typed request through context, trace, permits, execution, and placement, then reproduce the returned evidence. Each boundary below names what the component accepted, what it emitted, and what it preserved, so the pack replays against the same route.","canonical-stack-overview.surface.see-it-work.technical.detail-left":"The run below is the concrete test: inspect what each component accepted, emitted, and preserved at its boundary.","canonical-stack-overview.surface.see-it-work.technical.detail-right":"The route is the reference model for reproducing the returned trace, permits, execution, and placement evidence.","canonical-stack-overview.surface.home.consumer.eyebrow":"One connected path","canonical-stack-overview.surface.home.consumer.headline-lead":"Your request remains yours","canonical-stack-overview.surface.home.consumer.headline-accent":"all the way back","canonical-stack-overview.surface.home.consumer.body":"A question should not disappear into a black box. It should come back as a useful answer with a record you can understand.","canonical-stack-overview.surface.home.consumer.detail-left":"The route shows where knowledge, reasoning, action, and execution fit around your question.","canonical-stack-overview.surface.home.consumer.detail-right":"Most requests use only part of it, so the map explains the shape without prescribing a fixed journey.","canonical-stack-overview.surface.home.business.eyebrow":"From operation to accountable result","canonical-stack-overview.surface.home.business.headline-lead":"One operation on one stack","canonical-stack-overview.surface.home.business.headline-accent":"not eight projects","canonical-stack-overview.surface.home.business.body":"Start with an objective, its owner, sources, and policy. The stack coordinates the responsibilities it needs and returns the result, approvals, evidence, and record to the work surface.","canonical-stack-overview.surface.home.business.detail-left":"Each product can stand on its own, with a responsibility that remains clear when the operating path grows. An objective, its owner, its sources, and its policy are named at the start rather than assembled later.","canonical-stack-overview.surface.home.business.detail-right":"Together, explicit handoffs extend one path without rebuilding identity, governance, or evidence at every layer. The result, approvals, evidence, and record come back to the same work surface the request left from.","canonical-stack-overview.surface.home.technical.eyebrow":"Canonical request path","canonical-stack-overview.surface.home.technical.headline-lead":"The request is the thread","canonical-stack-overview.surface.home.technical.headline-accent":"and every handoff is visible","canonical-stack-overview.surface.home.technical.body":"A typed request carries pinned context through governed knowledge, woven cognition, authorised coordination, compute, and placement. The caller gets the result and the evidence chain together.","canonical-stack-overview.surface.home.technical.detail-left":"The architecture is composable rather than mandatory end to end; only the required responsibilities run. A typed request carries its pinned context into knowledge, cognition, coordination, compute, and placement only where those are needed.","canonical-stack-overview.surface.home.technical.detail-right":"Their contracts preserve request identity, declared boundaries, and reproducible return artefacts for the caller. The result and the evidence chain arrive together, so the caller does not have to reassemble one from the other.","core-extras.96d330537a":"Base IR","core-extras.bee831a169":"Substrate","core-extras.61a0822826":"Apps on Core","core-extras.15438cc098":"not supported","core-extras.ad565d9d01":"Feature","core-extras.0155bf03e5":"Segment legend","core-extras.8b7110078e":"Algorithm groups by data type","core-extras.25ab4276a6":"Scrollable capability matrix","dependency-manifest.e2e5bc0104":"7 products, one graph","dependency-manifest.564dc954d9":"Each product declares the provider contracts it consumes. Provider implementations never import their consumers.","dependency-manifest.516aae5295":"Resolution","dependency-manifest.3d9a95c16c":"direct deps, 0 duplicate implementations, 0 reverse imports, 0 cycles","dependency-manifest.23971b6ce2":"&quot;blake3 + ed25519&quot;","dependency-manifest.e9707a7d3e":"&quot;hard, bit-identical&quot;","dependency-manifest.66c1fdccef":"&nbsp;&nbsp;# provider contracts, never duplicated","dependency-manifest.7a2bfe940a":"# stack.lock, resolved from public contracts","dependency-manifest.fe0a091fdb":"Products","dependency-manifest.4ee39e6ac1":"providers only","dependency-manifest.fc7433d5df":"resolved, 0 cycles","dependency-manifest.58947c4162":"Work and interface","dependency-manifest.a010de5c61":"Fabric","dependency-manifest.e32bdad7aa":"Coordination and knowledge","dependency-manifest.af0854de67":"Aura","dependency-manifest.1e2db21a44":"Placement envelope","dependency-manifest.873132a799":"Mesh","dependency-manifest.24cc7edbe9":"Coordination and knowledge","dependency-manifest.4a86080d67":"Spindle","dependency-manifest.485a04fef4":"Nexus","dependency-manifest.73c7ed87d5":"Reasoning","dependency-manifest.0fed3b96cc":"Loom","dependency-manifest.1a73d72065":"Execution foundations","dependency-manifest.68836c550e":"Core","metric-matrix.79fd1355be":"Capability","oss-registry.004509e23e":"Fourteen repositories publishing to github.com/dweve-ai","oss-registry.35e965f8c2":"Clone, inspect, version-pin, and report issues per repository","oss-registry.e2ae20d9ae":"Rust","oss-registry.b407e87ccb":"14 implementation repositories","oss-registry.80906acb7b":"cargo add dweve-&lt;crate&gt;","oss-registry.c91597c8b9":"BitWeave","oss-registry.e81e548c36":"One typed API","oss-registry.cda05ca6d8":"Game runtime","oss-registry.39105b4667":"Jacquard","oss-registry.2a18584c6f":"Web to structured data","oss-registry.e5e429bcc9":"Data processing","oss-registry.ac4bbe17fe":"Winnow","oss-registry.79fa1cf524":"17 formats","oss-registry.029b7c0b8c":"Bindery","oss-registry.e8987f666d":"93% more per token","oss-registry.d007bb1b85":"HEDL","oss-registry.ac710df4fb":"Offline verifiable","oss-registry.5ce2e6f402":"Agent state","oss-registry.7ec3788793":"Knot","oss-registry.7266d952fb":"Verifiable runs","oss-registry.c4740e4ca2":"Execution records","oss-registry.de6848949f":"Selvedge","oss-registry.aa5cba1a92":"Hash-chained","oss-registry.1aa2f31ee7":"Ledger","oss-registry.293b9dcf84":"Linear-time verify","oss-registry.5f174de1cc":"Proof verification","oss-registry.df84637182":"AION","oss-registry.a26701efe1":"Byte-identical","oss-registry.84fb9bfc81":"Simulation","oss-registry.fd615fc047":"FMI","oss-registry.df9e5c0099":"Event-sourced","oss-registry.6f45a48a1f":"Twin","oss-registry.387582299d":"1.36 ns lookup","oss-registry.bb9cf14180":"Policy evaluation","oss-registry.03f923bd0d":"Lattice","oss-registry.de0b59eb35":"1.000 recall, ~35K QPS","oss-registry.01335793c7":"Search and retrieval","oss-registry.fa6e59b167":"On crates.io","oss-registry.1b3cf5033e":"Source parsing","oss-registry.188fb5d6cf":"Reed","oss-registry.956e3a0777":"0 ULP, correctly rounded","oss-registry.3edf0df499":"Deterministic math","oss-registry.cd84197771":"Numerus","oss-registry.role.numerus":"Runs deterministic fixed-point arithmetic with bit-identical results on every machine that compiles Rust.","oss-registry.role.reed":"Parses approved source into Merkle-certifiable structures whose provenance can be checked by hash.","oss-registry.role.bitweave":"Runs exact-recall binary hyperdimensional search on existing CPUs without a GPU.","oss-registry.role.lattice":"Compiles rules once into a memory-mapped binary for hot-path policy evaluation.","oss-registry.role.twin":"Folds an event-sourced log into any prior state so decisions can be replayed.","oss-registry.role.fmi":"Runs FMI 3.0 simulations deterministically with byte-identical results across every backend.","oss-registry.role.aion":"Produces reasoning certificates that any offline verifier can check in linear time.","oss-registry.role.ledger":"Maintains append-only, hash-chained event provenance that prevents quiet history edits.","oss-registry.role.selvedge":"Records a verifiable execution transcript for every sandboxed run, beyond process containment.","oss-registry.role.knot":"Signs every AI-agent state event with Ed25519 and commits each replayable run to a Merkle root.","oss-registry.role.hedl":"Serialises structured data densely for language models without carrying syntax overhead through every token.","oss-registry.role.bindery":"Reads and writes seventeen office document formats through one Rust API.","oss-registry.role.winnow":"Reads a recipe and returns structured data from the open web in one binary.","oss-registry.role.jacquard":"Provides a web-native, agent-first game engine where agents and designers share one typed API.","oss-registry.reedSourceAccess":"publishing in round six","oss-registry.repo.next":"1 September","oss-registry.repo.scheduled":"publishes in round {round}","page-breadcrumb.c766e66518":"Breadcrumb","product-map.5342a27487":"Built on","product-map.4a86080d67":"Spindle","product-map.485a04fef4":"Nexus","product-map.0fed3b96cc":"Loom","product-map.337df0cbb0":"Keeps conversations, knowledge, models, agents, flows, people, and evidence attached to the work they support.","product-map.f2285e1cc4":"One API","product-map.58947c4162":"Work interface","product-map.a010de5c61":"Fabric","product-map.9efdd29175":"Plans, executes, checks, and records development work against an explicit goal in a closed loop.","product-map.45a14cc899":"32 agents","product-map.e32bdad7aa":"Agent operations","product-map.af0854de67":"Aura","product-map.6f45a48a1f":"Twin","product-map.df84637182":"AION","product-map.68836c550e":"Core","product-map.cf79b07d4e":"Distributes bounded workloads across European compute nodes, prioritises local capacity, and returns an execution receipt.","product-map.d2caf2a944":"EU-wide","product-map.1e2db21a44":"Distributed compute","product-map.873132a799":"Mesh","product-map.03f923bd0d":"Lattice","product-map.c91597c8b9":"BitWeave","product-map.d588d0c8de":"Keeps sources, evidence, rights, history, and changes attached as knowledge is reused without loss.","product-map.0fa0d73ea1":"7 stages","product-map.24cc7edbe9":"Knowledge provenance","product-map.0bd68a9efb":"Forms executable organisations around an objective, with explicit roles, authority, handovers, recovery, and one work record.","product-map.30bdea833c":"8 modes","product-map.2108d7570e":"Activates the perception, memory, retrieval, reasoning, solver, verifier, and domain specialist threads required for each task.","product-map.6a7b34bf54":"528 domain specialists","product-map.73c7ed87d5":"Model orchestration","product-map.ba8ac97e12":"Silicon","product-map.188fb5d6cf":"Reed","product-map.cd84197771":"Numerus","product-map.7da3f70938":"Runs hundreds of thousands of hand-tuned compute kernels on existing hardware.","product-map.a268e26994":"96% less energy","product-map.1a73d72065":"Compute engine","product-map.b260c4058e":"Charter","product-map.c1c43c1f4e":"Business operations","product-map.ff39b9fa2a":"4 planes","product-map.dbc1b106df":"Connects customers, money, people, delivery, support, and knowledge on one company graph within an eligible licensed platform scope.","qa-block.002ff59811":"Question","qa-block.a16a4eda7c":"Answer","stack.83e5a0d3d2":"Stack","stack.d4a74b503a":"Read the docs","stack.8778e3b7cc":"Inspect the trace","stack.97f6f5f2a3":"Open AION","stack.c0c10a25cd":"Inspect a trace, the system map, or the foundation crates. Verify the arithmetic, dependency resolution, and proof format at the boundary where your risk is highest.","stack.7f938e3274":"Start with the boundary you need to verify","stack.90e40d5043":"Get started","stack.5745df21de":"An autonomous development agent in a single native binary, with a tamper-evident audit trail and Reed underneath. Works with Loom, works with any LLM.","stack.af0854de67":"Aura","stack.ca3b5e3393":"Event-sourced digital twins and a complete FMI 3.0 implementation on fixed-point arithmetic. Bit-exact simulation for medical, industrial, and defence domains.","stack.efa8fe1aa5":"Twin and FMI","stack.2e4844d6a9":"Local token compression via binary hypervector retrieval. 57 percent measured savings on technical prose, zero API cost at inference.","stack.a0cc6767cd":"Signum","stack.a9d381c82b":"A token-efficient data format for LLM applications. Half the tokens, same comprehension, because tokens are energy and energy is the bill.","stack.d007bb1b85":"HEDL","stack.73635fa35e":"Architecture diagrams as enforceable specifications: validate constraints, detect anti-patterns, generate infrastructure, stay in sync.","stack.8bd28d90f5":"Atlas","stack.1878e37430":"A tamper-evident, hash-chained event trail for everything agents and workflows do.","stack.1aa2f31ee7":"Ledger","stack.d2866efa1a":"Language-aware code intelligence: grammars compile to four parser engines with incremental reparse and cryptographic verification. An agent gets symbol-level knowledge of a codebase at any size and makes in-place edits in a handful of tokens. Grammar coverage is still growing.","stack.188fb5d6cf":"Reed","stack.b2f726cfe7":"Searches, scrapes, crawls, and collects structured data from the open web to legislation databases. One 40 MB binary, no runtime dependencies.","stack.ac4bbe17fe":"Winnow","stack.c691797222":"17 office document formats behind one API. We needed to read what enterprises actually have, so we wrote the reader.","stack.029b7c0b8c":"Bindery","stack.4a3cabb577":"Engineering, The stack","stack.ea7b247511":"we could not verify","stack.5c82f03769":"No dependency","stack.1d8c9204bf":"Winnow: 40 MB, no runtime dependencies","stack.fcbd9d976d":"Native binary","stack.1695c15fb0":"Signum compression on technical prose, zero API cost","stack.ad6c31bfe9":"Token savings","stack.d071b2f30d":"Bindery reads every enterprise format behind one API","stack.d227b9ffdf":"Doc formats","stack.14edec2b24":"Bindery, Winnow, Reed, Ledger, Atlas, HEDL, Signum, Twin, Aura","stack.4246018de7":"Internal libraries","stack.502ca3f08f":"Nine internal foundations","stack.b842e4e940":"TOOLS WE BUILT","stack.e07d33c0c1":"SIMULATION","stack.16de25af88":"CODE","stack.580393f5a9":"DATA","stack.016da0dd9c":"DOCUMENTS","stack.a1fccfabae":"These nine libraries fill contracts the products required but the team could not source with the needed verification properties: document parsing, web collection, code intelligence, event lineage, architecture validation, compact data, local retrieval, simulation, and agent execution.","stack.22c56479c8":"we needed it","stack.e18a15c1b1":"Built because","stack.fa04f31b41":"The workshop","stack.053f257976":"An auditor with a copy of the AION verifier can replay any trace produced anywhere in the stack, on any machine, without internet access.","stack.85c9683b7f":"Traces generated in an air-gapped environment are bit-identical to traces generated in Fabric. An auditor with a copy of the AION verifier binary can replay any trace produced anywhere in the stack, on any machine, without internet access.","stack.cc66f8ab84":"Policy evaluation (Lattice) and proof generation (AION) operate without network access. The policy engine is a pure function of its inputs and the loaded policy set. All proofs are verifiable offline against the Ed25519 signing key.","stack.e0022292e2":"Model weights are BLAKE3-addressed and delivered as a signed archive on encrypted physical media. The install script validates the hash before unpacking. If the hash does not match, the install aborts.","stack.9cda7e7b4e":"Licence validation is offline-signed. The licence token is a signed data structure verifiable with a public key embedded at build time. No phone-home required. An air-gapped install running a year after physical delivery can still validate its licence without any network access.","stack.65879168d6":"Licence verification, model delivery, policy evaluation, proof generation, and trace replay all have offline paths. Connectivity is a deployment choice, not a runtime precondition.","stack.dda0619c0d":"Designed for disconnected operation from the start","stack.b03d40a138":"Air-gap","stack.b7ff210aa0":"Air-gap and offline operation","stack.cc9c1afbd6":"Every fact shown in Fabric has a provenance chain to its source.","stack.587fbb3aa3":"Canonical record + citation graph","stack.415816bdc0":"Knowledge to interface","stack.4bf57a804a":"Spindle → Fabric","stack.ecff99ef9f":"State is derivable from log alone; no external state store required.","stack.9d1cff7bed":"Event log fold (pure function)","stack.928d491c8f":"State to model","stack.67aa6b345d":"Twin → Loom","stack.59f367d063":"No agent action executes without a verifiable permit in the trace.","stack.cd788012f1":"Signed permit tokens (Ed25519)","stack.a7f7bd6e43":"Policy to agents","stack.1d124bcbaf":"Lattice and AION → Nexus and Aura","stack.ab815b0fa9":"Every candidate traceable to its source document and hash.","stack.855c292a34":"Ranked candidate list + provenance chain","stack.646c62647d":"Retrieval to model","stack.dfbdf0c8ba":"BitWeave → Loom","stack.f22a076805":"Deterministic embedding; same document always maps to same bits.","stack.38b3b40063":"Binary embedding vectors (BLAKE3-addressed)","stack.e135cad834":"Compute to retrieval","stack.344f347dad":"Core → BitWeave","stack.e2aac45cbc":"Zero ULP variance across platforms before kernel selection.","stack.764507f644":"Fixed-point type algebra","stack.2be1d272f8":"Math to compute","stack.a7f4934da5":"Numerus → Core","stack.882c1af794":"Bit-identical arithmetic regardless of CPU generation.","stack.0d87553844":"SIMD intrinsics + memory layout","stack.ef4f8caec8":"Silicon to math","stack.d0fa2731f8":"Target hardware → Numerus","stack.b820dd4e85":"Guarantee","stack.6f00c1fccb":"Contract type","stack.0a5e7a0583":"Boundary","stack.39a1a65d63":"A boundary is a typed coupling surface: it defines the accepted input, returned output, and invariant the provider preserves. Consumers depend on that contract rather than the provider's implementation.","stack.f1d93cc6d9":"What crosses each system boundary","stack.90d3c71922":"System contracts","stack.8b40f42e78":"Interface contracts","stack.e3dd034bb8":"Architecture, Stack","stack.02e896d47f":"no reverse imports","stack.fc9ca87730":"Public contracts","stack.5e76f8498d":"CPU, GPU, FPGA, WASM","stack.d35260a00f":"Targets","stack.cb29da2677":"Provider direction only","stack.97f064aff5":"Cycles","stack.77b12b9236":"Each resolves cleanly","stack.fe0a091fdb":"Products","stack.f76717f175":"Resolved from public contracts","stack.637e3133ea":"RESOLUTION","stack.d19e97c9a9":"REPRODUCIBLE","stack.dc197e69dc":"NO CYCLES","stack.6757848af7":"DETERMINISTIC","stack.c0cca73fd0":"The dependency graph resolves into an exact manifest. Choose a product to inspect its responsibility, direct provider contracts, build determinism, targets, and proof scheme. Resolution rejects cycles and reverse imports.","stack.b37e6147b3":"resolved to exact artefacts","stack.71c70548eb":"The same graph,","stack.63a4b4a6b3":"Resolved manifest","stack.beda4fd2b6":"Q8.8 + Q31.32","stack.cd84197771":"Numerus","stack.d591b3b390":"Exact arithmetic","stack.14daea3866":"Multi-target","stack.d5f412e831":"Kera","stack.c41d4934c2":"Hundreds of thousands of hand-tuned kernels","stack.68836c550e":"Core","stack.c4740e4ca2":"Execution foundations","stack.873132a799":"Mesh","stack.53ebc572b4":"Placement envelope","stack.81ca01e36a":"LRAT + Alethe","stack.df84637182":"AION","stack.480129dea9":"<50 ns","stack.03f923bd0d":"Lattice","stack.5f174de1cc":"Policy and proof","stack.c16692515e":"35K+ QPS","stack.c91597c8b9":"BitWeave","stack.1fe0c00fbd":"~22 ns","stack.1ac9452818":"PAP","stack.7d15dd1bec":"Routing","stack.dec1fccaba":"Knowledge","stack.4a86080d67":"Spindle","stack.f5289b8aa6":"Dev agents","stack.64acf7e2a7":"Agents","stack.485a04fef4":"Nexus","stack.6a7b34bf54":"528 domain specialists","stack.0fed3b96cc":"Loom","stack.c698f940a0":"Intelligence","stack.4ca0a75c2b":"Workspace","stack.a010de5c61":"Fabric","stack.cda05ca6d8":"Work and interface","stack.a285f6bb79":"This is a directed acyclic graph, not a chain. Product surfaces declare the coordination, reasoning, evidence, and execution contracts they consume. Provider contracts do not import their consumers; shared libraries supply runtime, storage, security, telemetry, and transport.","stack.576224897c":"Products consume shared provider contracts","stack.bc674d2eea":"Dependency graph","stack.b4caea51bc":"You cannot silently change a dependency without changing the address of everything that depends on it.","stack.2b8d07af32":"Federated-first: no component requires a central coordination service. Twin and Spindle can operate disconnected; Mesh adds placement and coordination without becoming a prerequisite for local execution.","stack.9a8d814c29":"Deterministic scheduling: with pinned inputs and versions, Nexus workflow graphs replay the same action sequence. Parallelism is for performance, not for non-determinism.","stack.9ef60e7dba":"Sealed randomness: no system call to /dev/random or equivalent in the inference path. All randomness used during computation is seeded from the trace and reproducible.","stack.2d03b20e75":"no_std builds: Core ships without the standard library on constrained targets. This removes dynamic allocation from hot paths and its associated side-channel surface.","stack.077ab920a9":"Ed25519 signatures: every artefact that leaves a Dweve system is signed. Verification is offline. An air-gapped install with a year-old clock can still verify every artefact it received.","stack.0589a735be":"BLAKE3 content-addressing: every input, intermediate, output, model weight, policy file, and trace is identified by its hash. You cannot silently change a dependency without changing the address of everything that depends on it.","stack.367e58a49e":"These six properties live in shared runtime and build contracts. The five responsibility areas consume those contracts instead of duplicating security, reproducibility, and offline behaviour in each product.","stack.7f99dd7d68":"Properties shared through contracts","stack.bee831a169":"Execution invariants","stack.b35bc3bf3e":"Shared substrate","stack.70f1db6f9a":"Block-based decomposition with thousands of independently optimised blocks. Multiple replicas per block for parallel exploration with cross-replica exchange to escape local minima. Constraint mining locks optimal solutions; enables near-instant model retraining on new domains without full re-training cycles.","stack.a4f0f894df":"Hierarchical Simulated Annealing","stack.56de50e50d":"Loom reasoning","stack.b59e3ccb01":"HSA training","stack.ae6623731d":"Eight reasoning modes: deductive, inductive, abductive, analogical, causal, counterfactual, metacognitive, decision-theoretic. Confidence calibration and bias detection on every output. 31 perception extractors feed the meta-agent hierarchy. Episodic, semantic, working, and procedural memory subsystems.","stack.a450287b0f":"31 extractors, 8 reasoning modes","stack.d5adc33a2b":"Nexus coordination","stack.bea294e870":"Nexus reasoning","stack.1f53e40c1e":"Multi-level pipeline on the Kera deterministic IR: neural network graph to BitOps dialect to hardware lowering to native code (AVX-512, NEON, GPU kernels). Fused hybrid GEMM kernels combine accumulation, normalisation, activation, and packing to minimise memory traffic. Polyhedral loop optimisation for cache-efficient bit-packed layouts.","stack.79e31cb3d6":"Binary operations compiler on Kera","stack.d549d3942b":"Core execution","stack.5bfd93c6f8":"BitOps compiler","stack.5d5d773a17":"Maintains transformer-level quality with pure binary attention operations. Stochastic softmax with learned thresholds, binary dot products with VPOPCNTDQ acceleration, bit-plane expansion for critical attention heads. Dramatically reduced KV cache vs floating-point attention.","stack.85a9bfe6bb":"Magnitude-Preserving Binary Attention","stack.7d47f22cbc":"MPBA","stack.d7affee4ef":"Technical detail","stack.f43cb934f1":"Mechanism","stack.4343635cf2":"Component","stack.ab78341f04":"Three named mechanisms recur across responsibilities. Their design names make benchmark results, system cards, and implementation references unambiguous.","stack.0b0211c707":"Named mechanisms worth knowing","stack.88c6767aab":"Key mechanisms","stack.3f1cbfea58":"Same bits across every backend","stack.51ab88da6e":"0 ULP","stack.eafb833d1b":"Numerus variance","stack.3edf0df499":"Math","stack.de6a59fc7f":"exact 1.000 recall, sub-50ns p99, content-addressed; 4,808 QPS at 100K docs","stack.4f570c01ea":"BitWeave at 10K docs","stack.01335793c7":"Retrieval","stack.340cac2200":"2,000-400,000x faster than OPA on equivalent rules","stack.dcddee7283":"Lattice hot path","stack.bb9cf14180":"Policy","stack.65a32c9bd3":"Bit-packed XNOR and POPCOUNT, deterministic; separate from end-to-end throughput","stack.19b06c28f3":"MPBA inference speedup","stack.74e0b9c80d":"Attention","stack.3e14579995":"4 to 8 active domain specialists per token, PAP routing, 7-tier memory hierarchy","stack.c3b66e65dc":"Loom MoE","stack.551cfb69a4":"Domain specialists","stack.5c66902b76":"2,900+ operations and hundreds of thousands of hand-tuned kernels across 25 numeric formats and 12 backend targets, SIMD-specialised","stack.1156c5c351":"Core catalogue","stack.2b961dea1d":"Functions","stack.7c9a7c0610":"Detail","stack.5faa59d4bc":"Result","stack.b2bb7604c8":"Metric","stack.5530d87f43":"Each number in the table comes from a foundation benchmark or a commercial product benchmark published with its release.","stack.1aa2f85ba1":"The numbers worth checking","stack.4f46ac72b3":"Benchmarks","stack.0ecc3f94dc":"A trace generated in Rotterdam replays bit-identically in Munich, Tallinn, or offline in an air-gapped bunker.","stack.1d29b5b244":"CI runs over 10,000 unit tests, property tests, and fuzz targets on every commit. Release builds are additionally verified on three physical architectures. Hash mismatch fails the release.","stack.eaf91bce8a":"Every build output is stored by BLAKE3 hash. Dependency resolution is hash-based, not version-based. Pin an exact artefact or pin a semantic version range; the build system resolves to hashes in both cases.","stack.31adc54759":"Kera targets WASM, x86_64, AArch64, RISC-V, CUDA, and ROCm from a single source tree. The same Kera module compiles to GPU kernels or browser WASM without rewrite. ABI contracts are version-locked.","stack.c974623963":"Determinism is architectural, not best-effort. Core kernels are pure functions of their inputs. Numerus eliminates platform-dependent float paths. Reed's parser emits canonical AST hashes. The result: a trace generated in Rotterdam replays bit-identically in Munich, Tallinn, or offline in an air-gapped bunker.","stack.5e3fac4565":"Release builds resolve source, dependencies, and outputs to content addresses. Kera's multi-target compiler and CI rebuild tagged releases on three physical architectures and reject unexpected hash differences.","stack.130a8194fb":"Reproducible builds are not optional","stack.6e79e48e57":"Build system","stack.a827daca75":"Build system and determinism","stack.c82d1b09cf":"EU","stack.6bae8f7fc8":"x86/ARM","stack.aaa156e35a":"HW","stack.eb55f58903":"Commodity x86_64, AArch64, RISC-V RV64GC, and Shuttle FPGA. Unified intrinsics via Core backend abstraction. Bit-identical results across SSE2, AVX2, AVX-512, NEON, SVE2, scalar, CUDA, ROCm, Metal, Vulkan, WebGPU, and WASM targets.","stack.ba8ac97e12":"Silicon","stack.969b185f13":"Hardware targets","stack.0cae74747c":"Exact","stack.18b3dbacf0":"Deterministic fixed-point arithmetic: Q-format, Decimal, and AXIOM modes. Correctly-rounded transcendentals. 0 ULP variance across platforms. Replaces MPFR/Eigen in the hot path.","stack.6ae0d197a5":"Exact arithmetic","stack.e2ae20d9ae":"Rust","stack.3c54d5c7a0":"Reed: Merkle-certifiable parser with reproducible AST hashes. Kera: multi-target deterministic systems language compiling to WASM, x86, ARM, and CUDA. Build artefacts are BLAKE3-addressed.","stack.acc396ec1d":"Reed + Kera","stack.543c64bc34":"Languages and IR","stack.907a54c2b2":"Ops","stack.6de691384f":"SIMD","stack.0ada0736aa":"Hundreds of thousands of hand-tuned kernels across 2,900+ operations and 25 numeric formats (14 kernel data types including binary, ternary, Int2, Int4, Int8, FP8, FP16, BF16, FP32, FP64, plus 11 fixed-point Q-formats), via XNOR+POPCNT hot paths. 12 SIMD/GPU backend targets. no_std where shipped. Deterministic by architectural invariant.","stack.1a73d72065":"Kernel execution","stack.1316183ae7":"LSH","stack.86f6aa8016":"HDC","stack.6253a66985":"Deterministic binary retrieval with hyperdimensional computing and LSH. 35K+ QPS sustained at 10K docs. Sub-50ns p99 query latency. Exact 1.000 recall. No floating-point similarity drift. Content-addressed embedding store.","stack.fe0baadf17":"Deterministic retrieval","stack.93d2fc05f6":"Lattice: policy execution at runtime speed, 2,000-400,000x faster than OPA on equivalent rules. AION: proof machine with content-addressed replay. LRAT and Alethe output formats. Ed25519 signatures over BLAKE3 roots.","stack.65bcd49a55":"Lattice + AION","stack.3b0dc9b4a2":"Policy and proof","stack.b6ba0db1f8":"Fold","stack.c0f85d6679":"Replay","stack.6f45a48a1f":"Twin","stack.7f19c7426d":"Event-sourced digital twin. Append-only event log. Current state is a pure fold over the log. Deterministic replay without snapshot dependency. Ledger-backed provenance chain.","stack.532c07610f":"Replayable state","stack.b4c89cb5ed":"MoE","stack.e6ad4d6a45":"528-domain-specialist MoE. 64-128 MB per domain specialist. 4-8 active per token via PAP routing. 7-tier memory hierarchy (HBM, DDR, NVMe, LAN, WAN, cold, archive). Visible reasoning graph.","stack.73c7ed87d5":"Specialist model","stack.2bb9728270":"Nexus: the runtime for executable organisations. Nine kernel subsystems, popcount-scored staffing with a trace per routing decision, 8 reasoning modes (deductive, inductive, abductive, analogical, causal, counterfactual, metacognitive, decision-theoretic), policy-checked actions. Aura: 32 coding agents, 6 orchestration modes, military-style command hierarchy. Both traced by default.","stack.9532f6ab26":"Nexus + Aura","stack.2747397d42":"Agent coordination","stack.dd35a81646":"Provenance","stack.c5659831ba":"Seven-stage pipeline: ingest, extract, ground, review, canonicalise, sign, distribute. 32 specialised agents. DPIA artefacts generated by default. Full provenance chain.","stack.24cc7edbe9":"Versioned knowledge","stack.d93d10ff0f":"API","stack.f16e45b84e":"Managed Fabric surface: browser application, business API, Agent SDK, process design, and decision evidence on Dweve's public Mesh. It exposes managed capabilities without granting direct operation of the licensed products.","stack.17681aeb26":"Work surface","stack.0336a7e00c":"ZKP","stack.aff3e6943c":"Federated","stack.a421953a9a":"Federated compute, secure multi-party computation, zero-knowledge proofs, and libp2p transport. Contributors have their own subscription covered while they contribute. GAIA-X and IPCEI-CIS aligned.","stack.1e2db21a44":"Placement envelope","stack.e44f2a17d0":"The map groups products by responsibility instead of forcing peers into a false vertical order. Each boundary names the data it accepts, the result it returns, and the invariant it must preserve. Mesh wraps the map because placement applies to every part.","stack.85eac50bf5":"Five responsibilities, one end-to-end proof","stack.b040b4179b":"Architecture","stack.38a399f7b6":"System map and dependencies","stack.5142d972a0":"Determinism is not a model setting or policy promise. It follows from exact arithmetic, pinned artefacts, deterministic scheduling, and replayable state; the system map ties each guarantee to its provider contract.","stack.a0068b681c":"Integrators meet the contract they need: Core for execution, Lattice for policy, AION for proof, Loom for reasoning, Nexus and Aura for coordination, Spindle for knowledge, and Fabric for governed work.","stack.9f18fe402b":"Use the contract, inspect the mechanism","stack.bfa7440fe0":"What you see","stack.63a6354c6b":"Loom reasons in constraints, routed and resolved by solvers. The transformer inside it is small, 1-bit, and deterministic, and its only job is translating the solved result graph into coherent prose. The reasoning is already done, and already checkable, before a single word is generated.","stack.05c0e6b0a1":"The language model renders the solved graph","stack.0673efa838":"The model","stack.eb322ca1a9":"The SAT search uses integer-only conflict analysis. AION turns the result into BLAKE3-chained, Ed25519-signed certificates that a reviewer can check offline without access to the solver. A natural-language requirement can therefore travel with a machine-verifiable proof.","stack.148e08b5be":"Reasoning that produces certificates","stack.b316b9c711":"Proofs","stack.b970243605":"Kera is our own graph-native language and IR, not a wrapper on MLIR, not LLVM underneath. Every node is content-addressed by its BLAKE3 hash. Every fusion pass emits a machine-verifiable proof that the transformation preserved meaning. The same graph lowers to PTX, SPIR-V, and AMDGCN for GPUs, and to synthesizable Verilog for FPGAs, where even sigmoid becomes a fixed-point mux chain.","stack.1f5914591b":"A compiler that shows its work","stack.341a20e237":"Compiler","stack.c212ab6e34":"Numerus replaces floating point with fixed-point types that produce bit-exact results on every platform. Its transcendental functions are correctly rounded to 0 ULP against a 256-bit reference, its operations are proven with an SMT solver, its audit trails meet SOX, MiFID II, and FDA 21 CFR Part 11 with deterministic replay from the log itself, and its energy savings are measured with hardware power counters, not estimated.","stack.1b969ed097":"Arithmetic verified against a reference","stack.7e53821f70":"Numbers","stack.0509a287db":"Every claim a mechanism","stack.cdaa5552e5":"Mechanisms","stack.82b745f2d6":"Transcripted execution, tamper-evident trail.","stack.01645218b9":"Selvedge + Ledger","stack.ee913c7e60":"BLAKE3-chained, Ed25519-signed, checkable without the solver.","stack.d149a24c1a":"Offline certificates","stack.426557b5fb":"BLAKE3 content-addressed IR, verified fusion, synthesizable Verilog out.","stack.a7beb7601f":"Proof-carrying compiler","stack.71c9dd1a08":"x86, ARM, RISC-V, WASM, five GPU APIs. Equivalence-tested against a scalar reference.","stack.afdc2fbafe":"Scalar-verified kernels","stack.ea8f421a8d":"MPBA 1-bit attention and PAP structural similarity; published designs.","stack.90a4236251":"XNOR + POPCNT","stack.1c23f5f0ca":"0 ULP correctly rounded, SMT-proven, audit replay, energy measured with hardware counters.","stack.6fd826f20e":"Mapped to a claim","stack.1406189311":"THE MECHANISMS","stack.f61fa98a3b":"THE MODEL","stack.09ac5dfccc":"PROOFS","stack.e0dbcded97":"COMPILER","stack.0d97e1a302":"NUMBERS","stack.3edb0c4d85":"Conventional AI systems combine runtimes, accelerator libraries, floating-point kernels, and model code that were optimised independently. Pinning a model does not by itself pin arithmetic, scheduling, or artefact identity. Dweve specifies contracts for exact arithmetic, compilation, execution, evidence, and replay, then resolves products against them.","stack.7f3e749996":"the contracts constrain execution","stack.1c2a8fa542":"Deterministic because","stack.f335aff4a1":"Architecture from first principles","stack.5b139a9b9e":"Internal benchmarks. Replication artefacts published with each library.","stack.0d5aad8542":"At 10K docs, content-addressed, exact recall","stack.2fd8be5323":"BitWeave QPS","stack.c19597c8a3":"4-8 active per token, PAP routing","stack.911958ea9d":"Loom domain specialists","stack.2adaf79865":"Across 76 categories; hundreds of thousands of hand-tuned kernels across 25 numeric formats","stack.a1fdaa6b2a":"Operations","stack.38750ed448":"Stack at a glance","stack.03f8750341":"Talk to engineers","stack.e9d976b0f2":"Inspect a proof trace","stack.ccfeb18e09":"See the products","stack.8ef2f6fdf0":"Each product owns a named responsibility and declares the contracts it consumes. Compare the product map, inspect a trace, or discuss the boundary you need to replace or extend.","stack.1687be4c87":"Choose the responsibility you want to inspect","stack.5500eef9fd":"Next step","stack.92f47b0d3c":"Every decision carries its source, the rule applied, the owner, and a replay path. The trace is a product property, not a report you assemble afterwards.","stack.852930764f":"What happens when we are audited?","stack.d300a9e7d4":"No. Take Fabric as a workspace, use one API, license the full platform, or integrate a component at a public contract. The surrounding system does not have to change.","stack.fdbfee07b7":"Do we have to adopt the whole stack?","stack.989c270903":"Dweve is CPU-native across x86-64, ARM64, RISC-V, and FPGA. Managed customers use Fabric on the public Mesh; licensed customers operate the platform products directly on their infrastructure, including air-gapped estates.","stack.c4b6ca576c":"How does this fit our Azure or GPU cluster?","stack.877bfdde9e":"The products shown here run today, and each figure is tied to a benchmark or release artefact. Ask for a scoped proof of value on one of your own workflows.","stack.0612a5852b":"Can we run it in production today?","stack.a91aacee23":"Dweve stack","stack.96ce0678f2":"Behind every answer","stack.478360978f":"Four guarantees","stack.01fb03582c":"Adopt one product, several responsibilities, or the complete system at named contracts.","stack.d8f210efe6":"Composable","stack.03675ec6ed":"Runs on x86-64, ARM64, RISC-V, and FPGA. No GPU fleet required.","stack.e179db257b":"CPU-native","stack.a20f330cb5":"Source, rule, owner, and replay are attached as the work happens.","stack.6d4f5ec0dc":"Proof on every decision","stack.3daffb419f":"Managed Fabric, licensed, or air-gapped. Your data never depends on a US provider.","stack.d3dca5bc6d":"EU jurisdiction","stack.aa454f4542":"WHAT EVERY ANSWER RESTS ON","stack.5c762e0265":"AUDIT","stack.d63277d508":"COMPOSABLE","stack.d81271a891":"HARDWARE","stack.0e5d340180":"PRODUCTION","stack.81cfb4947b":"Before an architecture review signs off, four questions decide whether the stack is worth a pilot. Here they are, answered plainly.","stack.57e5e021db":"not a sales call","stack.2d826a2139":"Straight answers,","stack.337ed7bbac":"The questions you are already asking","stack.18b90aa6fa":"Full system map, contracts, and benchmarks.","stack.a049ca62fc":"Deep architecture","stack.64dd60fe1a":"Background","stack.23d91e7da2":"Replay and audit workflows.","stack.f21bbc6d82":"Proof surface","stack.787bf8cc60":"Proof generation and offline replay infrastructure.","stack.fdde6afa94":"Foundation","stack.c34f16f173":"Policy engine with a sub-50 ns hot path.","stack.4d77ce1172":"Deterministic binary retrieval with exact recall.","stack.af101f14da":"Fixed-point arithmetic with 0 ULP cross-platform variance.","stack.7626fc4895":"Governed workspace and API surface.","stack.dd3b86d1ef":"Product","stack.fd08bccaea":"Developer agents with 6 orchestration modes.","stack.cb4af17226":"Placement policy for federated European compute.","stack.a77951fddc":"Knowledge pipeline from candidate to canonical record.","stack.8c7fe6a1b7":"Governed multi-agent coordination.","stack.fb69791c70":"528-domain-specialist model with visible reasoning.","stack.4926eafa7b":"Execution catalogue with hundreds of thousands of hand-tuned kernels.","stack.8550c36a6f":"Choose a responsibility and inspect its contract","stack.1641d886bd":"Explore the stack","stack.a53b452ef1":"Read deeper","stack.e3341f6405":"Public contracts and EU deployment options reduce the scope of a migration: replace one responsibility without rewriting unrelated products.","stack.efcadb6f18":"Switching cost","stack.369c534df3":"Saving","stack.f182050b7d":"A replayable trace carries the source, rule, owner, and result. Audit teams can verify the decision without reconstructing evidence after the fact.","stack.1569d15bf1":"Audit effort","stack.e9862ae5ed":"No NVIDIA dependency. No custom accelerator lock-in. Runs on commodity x86, ARM, RISC-V, and FPGA you already own or can source from multiple vendors.","stack.a89ca60fd3":"Hardware independence","stack.279853c337":"The measured workload used 96% less energy than its GPU baseline. At volume, that changes both the operating bill and the capacity required for regulated workloads.","stack.437bcb1511":"Energy","stack.4f128273d7":"When ownership and dependency contracts are unclear, buyers inherit operational coupling, manual audit work, energy overhead, and a compliance case that is expensive to evidence. The system map makes those cost centres reviewable before procurement.","stack.4f8ea79b79":"The operating cost of opaque dependencies","stack.4390be5480":"Savings","stack.4d5c5740f5":"Cost and risk","stack.9315328cc8":"Source, proof formats, and compliance mappings are available for independent engineering and assurance review.","stack.904b9d6e8d":"Independent verification","stack.22789a1dc1":"Public contracts define the coupling surface. Replace Numerus, BitWeave, or Fabric without changing responsibilities that do not consume that contract.","stack.2a4f943a2e":"Modularity","stack.63c10ecd17":"Binary compute is used where the workload permits; standard precision remains where correctness requires it. The measured workload used 96% less energy than its GPU baseline.","stack.12c4ffe1d9":"Efficiency","stack.a925fd5ac5":"EU jurisdiction end to end. No foreign dependencies in the hot path. No extraterritorial access. Customer data never leaves unless the customer sends it.","stack.e03947cc0c":"Sovereignty","stack.3919711bae":"Every decision leaves a trace that regenerates the decision on demand. No tracing toggles; tracing is the mode.","stack.9e504d2d2b":"Auditability","stack.035e3304a2":"If two people run the same input on the same build, they get the same output. Always. No approximations, no tolerance bands.","stack.2956ef9ad6":"Determinism","stack.4c352ba89a":"Stack, principles","stack.d05d1a82ae":"OPENNESS","stack.f691d2046d":"MODULARITY","stack.9a62f3c09a":"EFFICIENCY","stack.b75ba6d5fe":"SOVEREIGNTY","stack.85fa00b67d":"AUDITABILITY","stack.93913696cd":"DETERMINISM","stack.f7bdfd5506":"These six principles map to operating controls: repeatable results, evidence captured during execution, EU deployment, measured compute efficiency, bounded coupling, and independent verification.","stack.01ed83600e":"mapped to controls","stack.982658e31d":"Six engineering principles","stack.4a8cf08007":"Principles","stack.faf1f5eb4b":"policy gate","stack.68f4127b67":"Compute","stack.68c2cc7f0c":"Model","stack.7b4db7ef1f":"Interface","stack.9cd444d665":"Arrows point from a consumer to the provider contract it uses. Provider code does not import its consumers, and each dependency is declared in the build files.","stack.d54bdeabf7":"One graph with declared dependency direction","stack.f509313e58":"System diagram","stack.222844d641":"Architecture diagram","stack.699f866433":"Homomorphic encryption, secure multi-party computation, and zero-knowledge proofs are available in paths that handle customer data.","stack.e2fab14775":"Privacy primitives","stack.41519a0835":"Primitive","stack.988e02a37f":"No component assumes a central service. Mesh distributes compute placement; Twin distributes state; Spindle distributes knowledge curation.","stack.ffd594b2fa":"Federated operation","stack.4b833c03b5":"Cryptographic hashes everywhere: inputs, intermediates, outputs, models, policies, traces. Identity is the hash; provenance is free.","stack.67a1cafc94":"Content-addressing","stack.323a00cc2b":"Same inputs, same build, same bytes out. Across CPUs, across operating systems, across months. No wall-clock dependency, no unseeded randomness.","stack.1b5d03cfce":"Weights and activations compressed to discrete states where possible. 96% energy reduction versus standard GPU baselines.","stack.5369aea7a0":"Binary compute","stack.f1467f3990":"system guarantees","stack.fa4e323c72":"Implementation mechanisms","stack.d1a6b4b2a1":"HE, SMPC, and ZKP are available for paths that handle customer data.","stack.1ccbd6d728":"No component assumes a central service. Mesh, Twin, and Spindle can operate disconnected.","stack.f18ffd95a1":"BLAKE3 hashes on inputs, intermediates, outputs, models, policies, traces.","stack.8a6c8c43a8":"Same inputs, same build, same bytes. No wall-clock, no unseeded randomness.","stack.d0e042be7d":"The measured binary-compute workload used 96% less energy than its GPU baseline.","stack.21c149d4be":"Cannot be switched off","stack.25e119bd9a":"STACK INVARIANTS","stack.2f15803450":"PRIVACY","stack.e60cfe62b4":"FEDERATED","stack.cda63691fe":"BINARY COMPUTE","stack.23a287d95f":"These five properties cross product boundaries. They control compute cost, make replay possible, preserve artefact identity, allow disconnected operation, and constrain how sensitive data is handled.","stack.43934152a0":"shared across products","stack.b14c17574d":"Five operating properties","stack.964a26b135":"Five invariants","stack.b1da8c9f00":"Cross-cutting primitives","stack.735dc4a777":"more to follow","stack.8967e5fafe":"Reed on crates.io","stack.274f4b6e2a":"Build and audit a known revision","stack.f6c82c9b8c":"Revisions","stack.0b5958b0f5":"Pinned","stack.aa23ac18e4":"Each one clone-and-auditable","stack.3744e80db8":"Open repos","stack.f1b3770d8e":"What the stack stands on","stack.e6d5698d73":"THE OPEN BASE","stack.1b337d6035":"AUDITABLE","stack.94101a40a4":"CLONE AND PIN","stack.c968638a6e":"REPRODUCIBLE BUILDS","stack.825b742371":"PUBLIC REPOSITORIES","stack.8182d84b15":"Fourteen libraries at github.com/dweve-ai implement the numeric, compiler, retrieval, policy, state, and data contracts used by the products. Review the code, pin a revision, and reproduce the relevant benchmark; each repository publishes its own licence.","stack.3e732f29d9":"expose the implementation","stack.be4cd9d90c":"Fourteen libraries","stack.2efa1e7572":"Foundations","stack.048b468fd9":"not eight","stack.ac044071a2":"Adopt one","stack.eef69726c2":"Underneath them all","stack.68f5a03d78":"Open foundations","stack.90a43f743f":"Shared capabilities consumed through named contracts","stack.22614de1a1":"Duplicate contracts","stack.c93442e722":"One coherent platform","stack.7b20f320a0":"Eight products, shared contracts","stack.4db4bac423":"ONE PLATFORM","stack.579a6a6fa9":"FABRIC","stack.14afd82a7f":"AURA","stack.cc036f8067":"MESH","stack.7830a84714":"SPINDLE","stack.abf754be72":"NEXUS","stack.e1111021ff":"LOOM","stack.6d917c2df3":"CORE","stack.c55b1e22b5":"Each commercial product owns a defined operational responsibility and consumes shared contracts instead of reimplementing them. Teams can adopt a product at an existing boundary while keeping the surrounding estate.","stack.c6801898f1":"owns and consumes","stack.70321c2840":"What each product","stack.eb94180ee9":"Product map","stack.bef4a0de27":"vs GPU baselines for equivalent workloads","stack.aa50825f45":"Less energy","stack.fc417da5f4":"BitWeave, 10K docs, exact recall","stack.f6e314ea55":"Retrieval QPS","stack.a4c900cc43":"Work, coordination, reasoning, evidence, and execution","stack.247d7d9884":"Responsibility areas","stack.92c1a64827":"What the connected stack delivers","stack.f3b62795f0":"See how proof works","stack.c9a1fcf79b":"Open Fabric","stack.5244a7be13":"Full architecture","stack.e223acec2a":"The technical view maps each responsibility, dependency, contract, and benchmark. It is built for engineers and buyers who need evidence before architecture approval.","stack.07db6adf8f":"Inspect the complete architecture","stack.eb4d3e9794":"Go deeper","stack.44d7075ead":"Ask why the system produced a result and the answer comes from the recorded sources, rules, and work. A reviewer can follow that record without asking the system to invent an explanation afterwards.","stack.fb008d1e1f":"The request, plan, proposed result, supporting record, and execution result cross named boundaries. If something needs attention, the team can inspect that handoff without taking the whole service apart.","stack.945dc8301f":"Stack, Consumer","stack.7b18504201":"across the system","stack.7b949e8fb0":"Four checks","stack.9a9333cf03":"96% less energy than the GPU baseline for the measured workload.","stack.5b0cec6cc3":"Sources, rules, decisions, and changes stay attached to the result.","stack.61d2e70b54":"Recorded evidence","stack.962d1ea6b2":"Data remains under EU jurisdiction throughout the work.","stack.cf01481f62":"Controlled placement","stack.c406633f25":"Each part receives a named input and returns a result the next part can check.","stack.819214edaf":"Clear handoffs","stack.af6169e264":"What stays true across the system","stack.cb349c0493":"WHY CLEAR BOUNDARIES MATTER","stack.071fd4d154":"TRACEABLE ANSWERS","stack.383a1196c4":"INSPECTABLE FOUNDATIONS","stack.57f3bce0a9":"ONE JOB PER PART","stack.c0a3ce1a25":"A clear boundary shows what went in, what came out, and which rule had to remain true. That makes a result easier to check and a problem easier to isolate.","stack.b5d6bbb5b1":"one result you can check","stack.10e1ab0d85":"Clear responsibilities","stack.33a579ffc0":"Trust","stack.a7dc26c5a2":"Why clear boundaries matter","stack.86e4c84393":"Commodity EU hardware.","stack.e66a2b063b":"Numerus, exact arithmetic.","stack.0eb3c1df5a":"Core, hand-tuned kernels.","stack.ba43626d5d":"BitWeave, deterministic search.","stack.df8f3c1e97":"Every decision leaves a trace.","stack.21d5c4f24e":"Loom, 528 specialist domain specialists.","stack.ee1d861bf5":"Nexus and Aura, governed logic.","stack.1ad54511bd":"Fabric, the screen you use.","stack.5eea3d1737":"Distributed European compute.","stack.6928fc39f3":"The system responds","stack.349644baab":"Press one button","stack.b098bd56a3":"Hardware in EU data centres.","stack.009715d569":"European silicon","stack.75967ec998":"Each part has a clear job and a named handoff.","stack.78ee4edcf1":"Five clear jobs","stack.c7178e51a0":"The library the assistant pulls from.","stack.c1813e2cb1":"The reasoning that forms the proposed result.","stack.e272c597fd":"Reasoning","stack.3492f3e21f":"The screen and the assistant in front of you.","stack.d89f92c399":"Press the button, ask the question.","stack.905cb326c7":"You","stack.93ab5bee1f":"Top to bottom","stack.30eb174fd8":"STACK IN PLAIN ENGLISH","stack.470da7bca8":"EU DATA ONLY","stack.c0c2518074":"EACH PART HAS ONE JOB","stack.65b79dbd75":"QUESTION TO CHECKABLE RESULT","stack.54e0294c34":"You ask one question. Fabric handles the work you see; other parts coordinate it, reason over it, keep the evidence, and execute the required computation. Mesh decides where those parts run. You do not need to learn the architecture, but its clear boundaries make the result easier to inspect.","stack.f5a8f53ef1":"one result you can inspect","stack.6228f881e3":"Five clear jobs","stack.1ab48943b6":"The stack in plain English","stack.430983dae5":"What the stack means for you","stack.9b61da63ea":"More than 10K unit, property and fuzz tests","stack.39fdec1194":"Tests","stack.ebb89231ef":"Rust, Kera, no_std where shipped","stack.89b86ab0e6":"Language","stack.78c0e8b6ba":"BLAKE3 throughout","stack.8c09a5c046":"Content-addressed","stack.40fdd38efc":"bit-identical across builds","stack.981443265d":"35K+ at 10K docs","stack.4d38cbfaa5":"528 MoE, 4-8 active","stack.0ac44a1447":"2,900+ across 76 categories","stack.a5d6990df5":"2,900+ operations across 76 categories","stack.d2f601ec0a":"Ops catalogue","stack.681df06cfa":"Stack, Technical","stack.aa2a84b29e":"SIGNAL SURFACE","stack.b9bef8d31f":"System map","stack.0a3d9f598f":"The architecture is organised by responsibility, not an arbitrary hierarchy. Fabric and Charter direct the work; Nexus, Aura, and Spindle coordinate actors and knowledge; Loom reasons; BitWeave, Lattice, AION, and Twin keep state, policy, and evidence; Core, Kera, Reed, and Numerus execute the computation. Mesh governs where it all runs. The implementation spans 2,900+ operations in 76 categories, 25 numeric formats, and 12 targets including SSE2, AVX2, AVX-512, NEON, SVE2, CUDA, ROCm, Metal, Vulkan, WebGPU, and WASM.","stack.87ca750f20":"One system, end to end","stack.3eee7b518e":"96% saved vs GPU baselines","stack.77a4214885":"EU-only end to end","stack.5d1cc3c5c6":"Jurisdiction","stack.0c36ef3513":"x86, ARM, RISC-V, FPGA","stack.b76ab65957":"Hardware","stack.998d117af7":"hundreds of thousands of hand-tuned kernels","stack.1ca27095b3":"8 (Numerus, Reed, BitWeave, Lattice, Twin, AION, Kera, HEDL)","stack.e6faa5ca4a":"8 (Core, Loom, Nexus, Spindle, Mesh, Aura, Fabric, Charter)","stack.d40af55817":"Commercial products","stack.41f1e0cfe6":"5 responsibilities plus Mesh placement","stack.f055f18aea":"System map","stack.e428a5aea0":"ARCHITECTURE SHEET","stack.43b791b48d":"View the diagram","stack.f6d759aedb":"Inspect the system map","stack.f2c3e04993":"AI procurement becomes risky when responsibility, dependency, and evidence are bundled behind one interface. Dweve maps who does what, which products carry each responsibility, which foundations they use, and what crosses each boundary. Buyers can review operational coupling, auditability, deployment, and cost before approval.","stack.72b3605df4":"Dweve names the responsibility, product owner, and contract behind each result.","stack.9674d4000b":"Inside Europe","stack.fe5c844489":"Data stays","stack.57a1f93860":"Regular CPUs, no special hardware","stack.5703321d0e":"Runs on","stack.b1b29e93ef":"8, all auditable","stack.de477c4e1d":"5 responsibilities plus Mesh placement","stack.4e6a22430e":"AT A GLANCE","stack.cf8fc19dfa":"See the full architecture","stack.0d589561e7":"Dweve separates the work you see from the coordination, reasoning, evidence, and execution underneath. Each part has a clear job, and Mesh decides where it runs. That makes an answer easier to check without asking you to learn the architecture.","stack.96ab46316b":"What the stack means for you","stack.e902cb4729":"The Stack","stack.a4f93f6b5e":"Placement","stack.f66904a90c":"Work surface","stack.3ecb9a7740":"Coordination","stack.9f74c42e48":"Reasoning","stack.62ae759aeb":"Policy","stack.d45531f0ca":"Retrieval","stack.9cabad367c":"Execution","stack.aa16640dd9":"Exact arithmetic","stack.8e029448a5":"Hardware target","stack.1dabba21cd":"✓","stack.079c79cfaa":"Knowledge","stack.f3b05c49f6":"Languages and IR","stack.bd23484a6c":"Replayable state","stack.c4f8c90db3":"orchestrates","stack.e0f895872d":"knowledge","stack.0c4d01e81b":"reasoning","stack.b04a12f648":"compute","stack.58a6d6801a":"math","stack.a41632db50":"distributes","stack.0f2625f67d":"NUM","stack.94383f71bb":"BITS","stack.85fc716dab":"KERN","stack.a21dedb8ad":"KERA","stack.37c66a2cfc":"AION","stack.ddeaded8ad":"RUN","stack.e3ad6abccd":"libp2p","stack.07193df400":"queries","stack.8a84e406c0":"route","stack.823412d1ea":"policy","stack.be6bdfe81e":"execute","stack.76a6ce8d85":"arith","stack.6706b672c3":"certify","stack.9372c470ee":"model","stack.50f2a151d1":"retrieve","stack.db8d1b6d64":"dispatch","stack.35e0d0360a":"LIVE","stack.236f415b20":"ALWAYS ON","stack.09a3684f49":"PORTFOLIO","stack.a601092e95":"GITHUB.COM/DWEVE-AI","stack.4bf5274611":"ARCHITECTURAL","stack.ac4e9ce52f":"THE ANCHORS","stack.ff6e828230":"GROUNDED","stack.272d01cbb8":"ONE DAG","stack.f35540e326":"FIRST-PARTY","stack.697c3252a8":"What the stack means","stack.c10f85ac94":"for you","stack.3a52bbb008":"What AI buyers need to see","stack.a000b65d5e":"responsibilities, contracts, and evidence","stack.0bcdeff3e5":"One system","stack.b7f4c362e1":"every handoff explicit","stack.4b73739598":"The operating costs","stack.c1c5b1a512":"of opaque dependencies","stack.f03d94d467":"One dependency graph","stack.8d3bb41df3":"contracts point to providers","stack.45532aa479":"Products and providers","stack.76c8f2af1a":"in one declared dependency graph","stack.353ed35a81":"Knowledge","stack.e65f6ab1f1":"State","stack.ad1f07d256":"Languages","stack.89c8a2851d":"Memory","stack.4775fe33f8":"Spindle, facts checked before they are used.","stack.280bdd3064":"Twin, state that can be replayed.","stack.26b3316b84":"Reed and Kera, the languages it is written in.","stack.03b581ff2a":"CHARTER","stack.system.product.charter":"Charter","stack.system.envelope.label":"Placement envelope","stack.system.envelope.title":"Mesh sets placement for all five responsibilities","stack.system.envelope.body":"Placement policy selects an allowed device, private cluster, or European region without changing the responsibility contracts.","stack.system.band.0.label":"Work and interface","stack.system.band.0.title":"Turn intent into governed work","stack.system.band.0.body":"Fabric holds the work object and its context. Charter keeps ownership, approvals, and operating rights explicit.","stack.system.band.1.label":"Coordination and knowledge","stack.system.band.1.title":"Route actors with the right knowledge","stack.system.band.1.body":"Nexus and Aura coordinate supervised action while Spindle supplies versioned, attributable knowledge.","stack.system.band.2.label":"Reasoning","stack.system.band.2.title":"Compose specialist reasoning","stack.system.band.2.body":"Loom selects and combines specialists, carries constraints through the graph, and returns the proposed result with its trace.","stack.system.band.3.label":"State, policy, and evidence","stack.system.band.3.title":"Keep meaning and provenance intact","stack.system.band.3.body":"BitWeave retrieves computable meaning; Lattice and AION enforce and attest policy; Twin records replayable state.","stack.system.band.4.label":"Execution foundations","stack.system.band.4.title":"Compile and run the work","stack.system.band.4.body":"Core executes the operation graph. Kera, Reed, and Numerus define its programs, representations, and arithmetic.","stack.consumer.band.0.name":"What you use","stack.consumer.band.0.body":"Fabric keeps your question, materials, choices, and result together.","stack.consumer.band.1.name":"What coordinates the work","stack.consumer.band.1.body":"The right tools and knowledge are brought in without making you manage them.","stack.consumer.band.2.name":"What reasons over it","stack.consumer.band.2.body":"Specialists are combined for the question instead of relying on one generic answer.","stack.consumer.band.3.name":"What keeps the record","stack.consumer.band.3.body":"Sources, corrections, rules, and changes remain available for inspection.","stack.consumer.band.4.name":"What carries it out","stack.consumer.band.4.body":"The required computation runs on an allowed device, cluster, or European region.","stack.consumer.side.kicker":"After you ask","stack.consumer.side.sub":"Five clear jobs behind one thread","stack.consumer.side.tag":"ONE THREAD","stack.consumer.side.marker":"READY","stack.consumer.side.foot.left":"Question enters","stack.consumer.side.foot.right":"Checkable result returns","stack.redo.breadcrumb":"Stack","stack.redo.hero.consumer.eyebrow":"Stack guide","stack.redo.hero.consumer.lead":"Map each owner","stack.redo.hero.consumer.accent":"trace answers","stack.redo.hero.consumer.lede":"The Dweve AI infrastructure stack is easier to understand when products, open-source foundations and research keep separate labels. This map follows the work from the surface you use to knowledge, reasoning, execution and placement, without pretending every connection is a software dependency.","stack.redo.hero.business.eyebrow":"Responsibility map","stack.redo.hero.business.lead":"Name the owner","stack.redo.hero.business.accent":"hold the line","stack.redo.hero.business.lede":"Procurement needs more than a layer diagram. This map separates the eight-product commercial suite, the separate Kera product, fourteen live open-source foundations and three research systems: Jacquard, Forge and Mycelia. It then distinguishes responsibility handoffs from real dependencies and optional integrations.","stack.redo.hero.technical.eyebrow":"System architecture","stack.redo.hero.technical.lead":"Trace contracts","stack.redo.hero.technical.accent":"not diagrams","stack.redo.hero.technical.lede":"Products own work, organisation, knowledge, cognition, execution and placement. Open-source projects own narrower mechanisms with their own licences. Kera remains a commercial systems product; Jacquard, Forge and Mycelia remain research. Directed relationships are labelled by what actually crosses the boundary.","stack.redo.hero.action.map":"Read the responsibility map","stack.redo.hero.action.products":"Open all products","stack.redo.hero.ledger.label":"Current inventory","stack.redo.hero.ledger.pill":"classified","stack.redo.hero.ledger.suite":"Commercial suite","stack.redo.hero.ledger.productRoutes":"Commercial products","stack.redo.hero.ledger.foundationRoutes":"Live foundations","stack.redo.hero.ledger.research":"Research systems","stack.redo.opening.business.title":"Accountable request","stack.redo.opening.business.sub":"objective to evidence","stack.redo.opening.business.tag":"preserved","stack.redo.opening.business.objective":"Operating objective","stack.redo.opening.business.owner":"Owner","stack.redo.opening.business.attached":"attached","stack.redo.opening.business.sources":"Sources","stack.redo.opening.business.pinned":"pinned","stack.redo.opening.business.policy":"Policy","stack.redo.opening.business.applied":"applied","stack.redo.opening.business.return":"Return record","stack.redo.opening.business.evidence":"Result with evidence","stack.redo.opening.technical.title":"Typed request contract","stack.redo.opening.technical.tag":"typed","stack.redo.opening.technical.input":"Typed input","stack.redo.opening.technical.context":"Governed context","stack.redo.opening.technical.result":"Traceable result","stack.redo.opening.technical.authorised":"Authorised plan","stack.redo.opening.technical.executable":"Executable plan","stack.redo.opening.technical.receipt":"Placement receipt","stack.redo.opening.technical.preserved":"identity preserved","stack.redo.section.sets.eyebrow":"Classification first","stack.redo.section.sets.lead":"Four sets","stack.redo.section.sets.accent":"four promises","stack.redo.section.sets.kicker":"Why the totals differ","stack.redo.section.layers.eyebrow":"Product responsibility","stack.redo.section.layers.lead":"Follow the work","stack.redo.section.layers.accent":"not the ranks","stack.redo.section.layers.kicker":"How to read the map","stack.redo.section.handoffs.eyebrow":"Responsibility handoffs","stack.redo.section.handoffs.lead":"Name what crosses","stack.redo.section.handoffs.accent":"not what embeds","stack.redo.section.handoffs.kicker":"The public contract","stack.redo.section.connections.eyebrow":"Directed connections","stack.redo.section.connections.lead":"Three relations","stack.redo.section.connections.accent":"three promises","stack.redo.section.connections.kicker":"The dependency rule","stack.redo.section.foundations.eyebrow":"Open-source foundations","stack.redo.section.foundations.lead":"Fourteen projects","stack.redo.section.foundations.accent":"four job groups","stack.redo.section.foundations.kicker":"The current live foundation set","stack.redo.section.research.eyebrow":"Research stays research","stack.redo.section.research.lead":"Research stays","stack.redo.section.research.accent":"separate","stack.redo.section.research.kicker":"Status integrity","stack.redo.pill.status":"Status","stack.redo.pill.routes":"Routes","stack.redo.pill.owner":"Owner","stack.redo.pill.contract":"Contract","stack.redo.pill.handoff":"Handoff","stack.redo.pill.dependency":"Dependency","stack.redo.pill.builtOn":"Built on","stack.redo.pill.worksWith":"Works with","stack.redo.pill.openSource":"Open source","stack.redo.pill.projectTerms":"Project terms","stack.redo.pill.research":"Research","stack.redo.pill.separate":"Separate","stack.redo.census.suite.name":"Commercial suite","stack.redo.census.suite.body":"Core, Loom, Nexus, Spindle, Aura, Mesh, Fabric and Charter form the licensed eight-product suite.","stack.redo.census.suite.state":"8 products","stack.redo.census.kera.body":"A separate commercial systems language and compiler product, licensed outside the eight-product suite.","stack.redo.census.kera.state":"product P09","stack.redo.census.foundation.name":"Open-source foundations","stack.redo.census.foundation.body":"Fourteen live detail pages, including Signum, with source status and licence owned by each project.","stack.redo.census.foundation.state":"14 pages","stack.redo.census.research.name":"Research programme","stack.redo.census.research.body":"Three distinct research systems: an agent-first game engine, verified program synthesis and deterministic artificial life.","stack.redo.census.research.state":"3 research systems","stack.redo.layer.surfaces.name":"Work and company surfaces","stack.redo.layer.surfaces.body":"Fabric owns governed AI work. Charter owns durable company operation.","stack.redo.layer.runtimes.name":"Action and organisation","stack.redo.layer.runtimes.body":"Aura owns the engineering action loop. Nexus owns the organisation formed around an objective.","stack.redo.layer.cognition.name":"Knowledge and cognition","stack.redo.layer.cognition.body":"Spindle maintains governed knowledge. Loom compiles the cognitive weave.","stack.redo.layer.execution.name":"Execution foundation","stack.redo.layer.execution.body":"Core owns AI operations. Selected Core paths can use Kera as the deeper graph-native foundation.","stack.redo.layer.placement.name":"Placement envelope","stack.redo.layer.placement.body":"Mesh intersects workload requirements with eligible nodes, trust domains and evidence obligations.","stack.redo.handoff.spindle.body":"Provides governed atoms, evidence packages, rights, conflicts and source lineage.","stack.redo.handoff.loom.body":"Compiles permitted knowledge into typed perception, memory, reasoning, solver and verification paths.","stack.redo.handoff.nexus.body":"Composes roles, authority, work structures, recovery and replay around the objective.","stack.redo.handoff.core.body":"Resolves and executes the required operation under a declared representation, backend and determinism contract.","stack.redo.handoff.mesh.body":"Places eligible work and returns the required operational receipt or a typed refusal.","stack.redo.handoff.fabric.body":"Keeps the work object, participants, approvals, sources and outcome visible to the people using it.","stack.redo.handoff.state.knowledge":"knowledge","stack.redo.handoff.state.reasoning":"cognition","stack.redo.handoff.state.organisation":"organisation","stack.redo.handoff.state.execution":"execution","stack.redo.handoff.state.placement":"placement","stack.redo.handoff.state.surface":"surface","stack.redo.connection.native.name":"Core Native","stack.redo.connection.native.body":"The broad Core product runs on its Rust-native execution foundation and does not require Kera.","stack.redo.connection.native.state":"native path","stack.redo.connection.kera.name":"Core on Kera","stack.redo.connection.kera.body":"A selected optional path places Core operations on Kera's graph-native planning and execution foundation.","stack.redo.connection.kera.state":"built on","stack.redo.connection.foundation.name":"Foundation integration","stack.redo.connection.foundation.body":"A product may embed a project or consume its typed artefact. The direction must be stated by the owning product or foundation page.","stack.redo.connection.foundation.state":"scoped claim","stack.redo.connection.placement.name":"Mesh placement","stack.redo.connection.placement.body":"A workload can require a Core operation, Kera runtime, local BitWeave index or Spindle package without turning placement into package ownership.","stack.redo.connection.placement.state":"requirement","stack.redo.foundation.winnow.body":"Compiles recurring source questions into governed collection, crawling, parsing, research and typed output.","stack.redo.foundation.bindery.body":"A document runtime that reads, creates, edits and interprets rich office documents through one model.","stack.redo.foundation.hedl.body":"A compact structured-data format and toolchain designed for the reader that charges by the word.","stack.redo.foundation.reed.body":"Private code intelligence that reads, structures, connects, queries and changes repositories with receipts.","stack.redo.foundation.signum.body":"A local prompt compressor that removes words by published rules while preserving protected content.","stack.redo.foundation.numerus.body":"Deterministic arithmetic across fixed-point, decimal, adaptive and integer families with replayable records.","stack.redo.foundation.bitweave.body":"Computable Meaning: binary hypervectors for composition, search, storage, generation and semantic state.","stack.redo.foundation.lattice.body":"An AI governance engine that evaluates named rules, constraints, reasoning and outcomes through inspectable artefacts.","stack.redo.foundation.aion.body":"A certificate system with typed proof, reasoning, organisational, compilation, execution and simulation families.","stack.redo.foundation.ledger.body":"A general tamper-evident audit log with pluggable storage, sessions, verification and software interfaces.","stack.redo.foundation.knot.body":"A verifiable agent event log with ingest-time redaction, signatures, per-run Merkle roots and replay.","stack.redo.foundation.selvedge.body":"A sandbox for untrusted code that returns an execution record, capability decisions and verifiable receipts.","stack.redo.foundation.fmi.body":"An FMI 3 runtime and solver fabric that keeps one model contract across simulation backends and Twin handoff.","stack.redo.foundation.twin.body":"Operational memory for commands, events, derived state, temporal branches, standards adapters and live twins.","stack.redo.foundation.group.input":"Source and representation","stack.redo.foundation.group.input.body":"Winnow, Bindery, HEDL, Reed and Signum own collection, documents, compact exchange, code reading and prompt compression.","stack.redo.foundation.group.formal":"Meaning and formal methods","stack.redo.foundation.group.formal.body":"Numerus, BitWeave, Lattice and AION own arithmetic, computable meaning, governance and certificates.","stack.redo.foundation.group.record":"Records and protected execution","stack.redo.foundation.group.record.body":"Ledger, Knot and Selvedge own audit records, agent events and sandboxed execution receipts.","stack.redo.foundation.group.simulation":"Simulation and operational state","stack.redo.foundation.group.simulation.body":"FMI and Twin own model execution, solver-backed simulation and operational memory over time.","stack.redo.research.jacquard.body":"A web-native, AI-agent-first game engine with a typed world API. Its release status remains research.","stack.redo.research.jacquard.state":"agent-built worlds","stack.redo.research.forge.body":"A program synthesis engine that searches typed expressions, measures candidates and checks bounded correctness obligations with formal solvers.","stack.redo.research.forge.state":"verified synthesis","stack.redo.research.mycelia.body":"A deterministic artificial-life substrate for local physics, chemistry, biology, ecology and information constraints.","stack.redo.research.mycelia.state":"artificial life","stack.redo.research.kera.body":"A commercially licensed systems language and compiler product. Its graph-native role does not make it open source.","stack.redo.research.kera.state":"commercial product","stack.redo.route.products.name":"Product index","stack.redo.route.products.body":"The canonical index at /products covers eight suite products plus the separate Kera product route.","stack.redo.route.foundations.name":"Foundation index","stack.redo.route.foundations.body":"The /open-source index exposes fourteen live foundation detail pages and keeps project terms separate.","stack.redo.route.research.name":"Research programme","stack.redo.route.research.body":"Jacquard, Forge and Mycelia remain research rather than being counted as products or open-source foundations.","stack.redo.inventory.products":"Commercial products","stack.redo.inventory.foundations":"Open-source foundations","stack.redo.inventory.research":"Research programme","stack.redo.consumer.sets.body":"Products are the parts people and organisations operate. Foundations are smaller open-source projects with focused jobs. Kera is a product even though it sits deep in the system. Jacquard, Forge and Mycelia remain research.","stack.redo.consumer.sets.detail":"That is why the totals are not one big number. There are eight suite products, nine commercial products after Kera is included, fourteen live foundations after Signum is included, and three separate research systems.","stack.redo.consumer.sets.footer":"With the sets separated, the product hierarchy can follow the work itself.","stack.redo.business.sets.body":"Commercial scope, source status and research status answer different questions. Collapsing them would misclassify Kera, hide Signum or present research work as a release promise.","stack.redo.business.sets.detail":"The licensed suite contains eight named products. The broader commercial set contains those eight plus Kera. The live foundation set contains fourteen projects. Jacquard, Forge and Mycelia remain separate research systems.","stack.redo.business.sets.footer":"The next layer assigns one commercial owner to each system responsibility.","stack.redo.technical.sets.body":"The commercial taxonomy and source-status taxonomy are not isomorphic. Kera adds one commercial product without becoming a peer surface in the eight-product suite. Signum brings the live foundation inventory to fourteen.","stack.redo.technical.sets.detail":"This page states the counting rule rather than inferring source status from directory placement. Each foundation owns its licence, Kera remains commercially licensed, and Jacquard, Forge and Mycelia remain research.","stack.redo.technical.sets.footer":"Now the architecture can be read as contracts instead of directory structure.","stack.redo.consumer.layers.body":"A question begins where you work. Knowledge is prepared, the right kind of reasoning is assembled, the calculation runs and Mesh checks where it is allowed to happen. Each step keeps a named owner.","stack.redo.consumer.layers.subtitle":"A question keeps one named owner as it moves toward placement. The bands show where responsibility changes, not a rank of products.","stack.redo.consumer.layers.detail":"The map is not a ladder of importance. It is a sequence of responsibilities. Fabric and Charter own the visible records. Aura and Nexus organise action. Spindle and Loom own knowledge and cognition. Core and selected Kera paths execute. Mesh surrounds placement.","stack.redo.consumer.layers.footer":"Mesh is an envelope around eligible execution, not another reasoning layer.","stack.redo.consumer.layers.bannerTitle":"A capable machine is not always an eligible machine","stack.redo.consumer.layers.bannerLead":"Capability alone","stack.redo.consumer.layers.bannerAccent":"cannot place work","stack.redo.consumer.layers.bannerBody":"Mesh checks location, ownership, availability, security and the evidence that must come back before it places the work. If no machine meets the rules, the refusal stays visible.","stack.redo.business.layers.body":"The hierarchy is arranged by accountable responsibility: work and company state, action and organisation, knowledge and cognition, execution, then placement. It does not imply that every request traverses every product.","stack.redo.business.layers.subtitle":"Accountability follows the responsibility that must hold the result. The map gives buyers an owner to question at each operational boundary.","stack.redo.business.layers.detail":"A customer can adopt one surface or licence a deeper product. The map shows which owner answers when a result depends on knowledge, reasoning, agent authority, numerical execution or infrastructure placement.","stack.redo.business.layers.footer":"Placement is the outer operating boundary and deserves its own visual envelope.","stack.redo.business.layers.bannerTitle":"Placement is governance expressed as a scheduler input","stack.redo.business.layers.bannerLead":"Governance becomes","stack.redo.business.layers.bannerAccent":"placement input","stack.redo.business.layers.bannerBody":"Mesh intersects capability with tenancy, jurisdiction, trust, availability, evidence and service conditions before the job begins. Raw capacity alone never qualifies a node.","stack.redo.technical.layers.body":"The product map is a responsibility decomposition, not a universal call graph. Fabric and Charter are domain surfaces, Aura and Nexus are runtimes, Spindle and Loom maintain knowledge and cognition, Core executes, optional Kera paths deepen compilation, and Mesh places.","stack.redo.technical.layers.subtitle":"The decomposition names contracts without pretending to be a universal call graph. A trace may skip bands while retaining each crossing's evidence boundary.","stack.redo.technical.layers.detail":"A real trace can omit entire bands. A deterministic local Core run may never touch Mesh. A Fabric workflow can call an external model. The invariant is that each crossing retains its own typed contract and evidence boundary.","stack.redo.technical.layers.footer":"Mesh evaluates the workload-node intersection only when placement is part of the run.","stack.redo.technical.layers.bannerTitle":"The placement envelope can refuse a technically valid workload","stack.redo.technical.layers.bannerLead":"Valid workloads","stack.redo.technical.layers.bannerAccent":"may still be refused","stack.redo.technical.layers.bannerBody":"Runtime, artefact, data-residency, security, telemetry, determinism and receipt requirements are compared with node capabilities and trust-domain policy before scheduling.","stack.redo.consumer.handoffs.body":"The same answer can move through several responsibilities without every product becoming part of every other product. What crosses is a useful object: governed knowledge, a reasoning result, an approved task, an operation or a receipt.","stack.redo.consumer.handoffs.subtitle":"Follow the artefact, then name the next accountable owner. The chain distinguishes a useful handoff from a shipped dependency.","stack.redo.consumer.handoffs.detail":"A handoff tells you who produced the object and what the next product may do with it. It does not automatically mean that one product ships inside the other, and that stronger claim needs its own evidence before anyone plans around it as a dependency.","stack.redo.consumer.handoffs.footer":"That distinction matters most when somebody claims the stack is built on a named project.","stack.redo.business.handoffs.body":"Responsibility handoffs let a buyer follow accountability without inflating the software bill of materials. Spindle can provide knowledge to Loom without the phrase alone proving an embedded package dependency.","stack.redo.business.handoffs.subtitle":"A buyer can trace an object across owners without inflating the bill of materials. Each crossing identifies the accountable producer and consumer.","stack.redo.business.handoffs.detail":"The public contract names the object crossing the boundary, the producer, the consumer and the evidence retained. A dependency claim requires the stronger fact that the component ships inside the product.","stack.redo.business.handoffs.footer":"The next section applies that stricter rule to the connections the current product facts support.","stack.redo.technical.handoffs.body":"Architecture edges are typed responsibility edges. Governed atoms, weave artefacts, task graphs, execution cells, placement decisions and composition records retain separate schemas and owners.","stack.redo.technical.handoffs.subtitle":"Typed artefacts cross boundaries; package edges require stronger evidence. The object, owner and schema stay explicit at each handoff.","stack.redo.technical.handoffs.detail":"Do not infer a package edge from an artefact edge. A product can consume an exported record, call a supported interface or request placement without embedding the producer's implementation.","stack.redo.technical.handoffs.footer":"Dependency direction is now stated only where the source facts establish it.","stack.redo.consumer.connections.body":"Some products contain a component, some can connect to it, and some only pass work to it. Those are different promises. Core Native works without Kera; Core on Kera is a selected optional deeper path.","stack.redo.consumer.connections.subtitle":"Keep package dependencies, integrations and handoffs on separate tracks. The ledger says what each edge promises before a route is chosen.","stack.redo.consumer.connections.detail":"Mesh can place work that asks for a Kera runtime, Core operation or local knowledge package. That tells Mesh what the machine must have. It does not make Mesh the owner of those products.","stack.redo.consumer.connections.footer":"Open-source projects use the same rule: name the real job and keep the direction honest.","stack.redo.consumer.connections.bannerTitle":"Three verbs prevent one inflated stack claim","stack.redo.consumer.connections.bannerLead":"Three verbs","stack.redo.consumer.connections.bannerAccent":"protect the meaning","stack.redo.consumer.connections.bannerBody":"Built on means a real dependency ships inside the product. Works with means an optional integration. Handoff means one typed result crosses a responsibility boundary.","stack.redo.business.connections.body":"The clearest verified commercial dependency is directional: Core can run on its native foundation or use Kera for selected licensed paths. Kera is not presented as depending on Core.","stack.redo.business.connections.subtitle":"Only verified dependency direction belongs in the commercial ledger. Optional integrations and workload requirements keep their own commercial meaning.","stack.redo.business.connections.detail":"Foundation relationships need the same discipline. Name an embedded dependency only when the current product or foundation facts assert it. Otherwise describe the supported integration, exported artefact or placement requirement.","stack.redo.business.connections.footer":"That language keeps the open-source registry useful without turning every integration into product ownership.","stack.redo.business.connections.bannerTitle":"Built on is a commercial and technical claim","stack.redo.business.connections.bannerLead":"Built on carries","stack.redo.business.connections.bannerAccent":"commercial weight","stack.redo.business.connections.bannerBody":"It affects replacement, support and licensing analysis, so the phrase is reserved for a real dependency. Optional integrations and responsibility handoffs keep their own labels.","stack.redo.technical.connections.body":"Core Native is independent of Kera. Core on Kera is an optional selected deployment path. Mesh workload constraints may require Core, Kera, BitWeave or Spindle artefacts, but that is a scheduler eligibility relation.","stack.redo.technical.connections.subtitle":"Dependency, integration and eligibility stay distinct in the edge ledger. Unknown direction remains unknown until a source establishes it.","stack.redo.technical.connections.detail":"The stack therefore keeps package edges, protocol or artefact integrations, and workload requirements in separate ledgers. Unknown direction is not filled in from proximity on a diagram.","stack.redo.technical.connections.footer":"The foundation census can now describe projects by job rather than by imagined parent product.","stack.redo.technical.connections.bannerTitle":"Dependency, integration and handoff are separate edge types","stack.redo.technical.connections.bannerLead":"Three edge types","stack.redo.technical.connections.bannerAccent":"three contracts","stack.redo.technical.connections.bannerBody":"A package edge changes the shipped product. An integration edge enables a supported crossing. A handoff edge transfers a typed artefact between owners. The graph is only useful while those meanings stay distinct.","stack.redo.consumer.foundations.body":"The open-source foundations do focused jobs underneath or beside the products: collect sources, read documents and code, compress text, represent meaning, calculate exactly, check rules, record events and model systems over time.","stack.redo.consumer.foundations.subtitle":"Each project keeps a focused job, licence and release boundary. The groups make those boundaries visible without turning research into a product.","stack.redo.consumer.foundations.detail":"Each project keeps its own scope and terms. The list includes Signum and therefore contains fourteen live foundations. Jacquard, Forge and Mycelia stay in the research programme; Kera stays a commercial product.","stack.redo.consumer.foundations.footer":"The last boundary keeps research and commercial product status out of that foundation count.","stack.redo.business.foundations.body":"Fourteen live foundation pages expose narrower mechanisms that can be inspected, replaced or integrated independently. Their source status and licences belong to each project, not to the commercial product that may use one.","stack.redo.business.foundations.subtitle":"The registry groups projects by job, source status and licence. That makes replacement and diligence questions easier to scope.","stack.redo.business.foundations.detail":"The registry is grouped by operational job rather than an invented vertical hierarchy: source and representation, meaning and formal methods, records and protected execution, and simulation and operational state.","stack.redo.business.foundations.footer":"Research remains a separate evidence and release category.","stack.redo.technical.foundations.body":"The current foundation set contains Winnow, Bindery, HEDL, Reed, Signum, Numerus, BitWeave, Lattice, AION, Ledger, Knot, Selvedge, FMI and Twin. Jacquard, Forge and Mycelia stay in the research programme, and Kera remains a commercial product rather than a foundation.","stack.redo.technical.foundations.subtitle":"Fourteen projects are grouped by mechanism, not inferred build order. Each project retains its own crate, artefact and licence boundary.","stack.redo.technical.foundations.detail":"The grouping is descriptive, not a build order. Each project exposes its own crate, binary, protocol, artefact or verifier surfaces and owns its own licence. Cross-project relations remain typed and directional.","stack.redo.technical.foundations.footer":"Three research systems remain deliberately outside the OSS census.","stack.redo.consumer.research.body":"Jacquard, Forge and Mycelia are presented as research, not as released open-source foundations. Kera is a product, not a research project. Keeping those labels visible prevents research access from becoming a promise about release terms.","stack.redo.consumer.research.subtitle":"Research claims stay visible without becoming product promises. Each line keeps its evidence question and release status in view.","stack.redo.consumer.research.detail":"Jacquard studies agent-built worlds, Forge studies program synthesis with verification, and Mycelia studies deterministic artificial life. Each line keeps a distinct question and evidence model.","stack.redo.consumer.research.footer":"The map closes with every set, owner and status named once.","stack.redo.consumer.research.closeTitle":"Open the set you actually need","stack.redo.consumer.research.closeBody":"Choose products for operated capabilities, foundations for focused open-source mechanisms and research for work whose release status remains separate.","stack.redo.business.research.body":"Jacquard, Forge and Mycelia remain research. They should not be counted as open-source foundations or supported products in procurement material. Kera remains a commercially licensed product despite its low position in the execution architecture.","stack.redo.business.research.subtitle":"Release status remains a diligence question, separate from commercial scope. Research evidence should not be priced as a supported product.","stack.redo.business.research.detail":"This boundary protects due diligence. Commercial scope, source availability and research release status can now be checked without reversing relationships from a diagram or inheriting a disputed total.","stack.redo.business.research.footer":"The stack is complete when every status can be traced to its accountable owner.","stack.redo.business.research.closeTitle":"Move from the map to accountable detail","stack.redo.business.research.closeBody":"Review commercial scope in the product index, source and licence terms in the foundation index, or inspect how one result crossed the system in a trace.","stack.redo.technical.research.body":"Jacquard studies replayable agent-built worlds, Forge studies program synthesis with verification, and Mycelia studies deterministic artificial life. All three remain outside the foundation census. Kera remains a commercial product and outside the OSS census.","stack.redo.technical.research.subtitle":"Each research system keeps its own claim, apparatus and release status. The evidence model changes with its state space and failure mode.","stack.redo.technical.research.detail":"The apparatus changes with the claim, state space and failure model. Jacquard uses typed world state and replay, Forge uses measured candidates and formal solvers, and Mycelia uses conservation and cross-target checks.","stack.redo.technical.research.footer":"The commercial, source-status and research taxonomies now stay separate.","stack.redo.technical.research.closeTitle":"Inspect the contract at its source","stack.redo.technical.research.closeBody":"Product pages define commercial capability, foundation pages define focused open-source mechanisms and the trace page shows the typed crossings that occurred in one run.","stack.redo.side.sets.label":"Census","stack.redo.side.sets.sub":"four status sets","stack.redo.side.sets.tag":"current","stack.redo.side.sets.footLeft":"counting rule","stack.redo.side.sets.footRight":"explicit","stack.redo.side.layers.label":"Product bands","stack.redo.side.layers.sub":"one owner per job","stack.redo.side.layers.tag":"mapped","stack.redo.side.layers.footLeft":"hierarchy","stack.redo.side.layers.footRight":"responsibility","stack.redo.side.layers.evidenceFooter":"Five bands, one named owner at each boundary.","stack.redo.side.handoffs.label":"Typed crossings","stack.redo.side.handoffs.sub":"object before package","stack.redo.side.handoffs.tag":"handoff","stack.redo.side.handoffs.footLeft":"edge type","stack.redo.side.handoffs.footRight":"public contract","stack.redo.side.handoffs.evidenceFooter":"Each crossing names the object before any package claim.","stack.redo.side.connections.label":"Connection ledger","stack.redo.side.connections.sub":"direction retained","stack.redo.side.connections.tag":"scoped","stack.redo.side.connections.footLeft":"unknowns","stack.redo.side.connections.footRight":"not inferred","stack.redo.side.connections.evidenceFooter":"Every edge keeps its direction and relationship type.","stack.redo.side.foundations.label":"Foundation groups","stack.redo.side.foundations.sub":"four operational jobs","stack.redo.side.foundations.tag":"14 live","stack.redo.side.foundations.footLeft":"source status","stack.redo.side.foundations.footRight":"per project","stack.redo.side.foundations.evidenceFooter":"Four groups keep source status and licence terms separate for fourteen projects.","stack.redo.side.research.label":"Status boundary","stack.redo.side.research.sub":"three research systems","stack.redo.side.research.tag":"separate","stack.redo.side.research.footLeft":"release status","stack.redo.side.research.footRight":"research","stack.redo.side.research.evidenceFooter":"Three systems remain research, outside the product count.","stack.redo.frame.sets.title":"stack / classification-ledger","stack.redo.frame.sets.meta":"8 / 9 / 14 / 3","stack.redo.frame.sets.verdict":"Commercial scope, foundation scope and research status remain distinct.","stack.redo.frame.layers.title":"stack / responsibility-bands","stack.redo.frame.layers.meta":"5 bands","stack.redo.frame.layers.verdict":"The map follows owned responsibility, not an arbitrary product rank.","stack.redo.frame.handoffs.title":"stack / typed-handoffs","stack.redo.frame.handoffs.meta":"6 owners","stack.redo.frame.handoffs.verdict":"An artefact crossing is not automatically a package dependency.","stack.redo.frame.connections.title":"stack / connection-ledger","stack.redo.frame.connections.meta":"3 edge types","stack.redo.frame.connections.verdict":"Direction and relationship type stay attached to every claim.","stack.redo.frame.foundations.title":"stack / foundation-registry","stack.redo.frame.foundations.meta":"14 live foundations","stack.redo.frame.foundations.verdict":"Focused jobs, project-specific licences and no invented parent layer.","stack.redo.frame.research.title":"stack / research-inventory","stack.redo.frame.research.meta":"3 research systems","stack.redo.frame.research.verdict":"Jacquard, Forge and Mycelia keep explicit research status.","stack.redo.frame.status.classified":"classified","stack.redo.frame.status.owned":"owned","stack.redo.frame.status.handedOff":"handed off","stack.redo.frame.status.scoped":"scoped","stack.redo.frame.status.routed":"routed","stack.redo.frame.status.separated":"separated","stack.redo.banner.mesh.eyebrow":"Placement envelope","stack.redo.banner.mesh.verdict.label":"Placement decision","stack.redo.banner.mesh.workload.name":"Declared workload","stack.redo.banner.mesh.workload.body":"Runtime, artefact, location, security, resource and evidence requirements enter together.","stack.redo.banner.mesh.workload.state":"requirements","stack.redo.banner.mesh.body":"Intersects the workload contract with the current node, trust-domain and governance state.","stack.redo.banner.mesh.state":"eligible or refused","stack.redo.banner.mesh.receipt.name":"Result and receipt","stack.redo.banner.mesh.receipt.body":"The output returns with the evidence contract requested, or the refusal names what could not be met.","stack.redo.banner.mesh.receipt.state":"recorded","stack.redo.banner.relation.eyebrow":"Relationship grammar","stack.redo.banner.relation.verdict.label":"Typed relation","stack.redo.banner.relation.built.name":"Built on","stack.redo.banner.relation.built.body":"The dependency ships inside the product and affects its replacement and support boundary.","stack.redo.banner.relation.built.state":"dependency","stack.redo.banner.relation.works.name":"Works with","stack.redo.banner.relation.works.body":"A supported integration can be enabled without redefining the product's core ownership.","stack.redo.banner.relation.works.state":"integration","stack.redo.banner.relation.handoff.name":"Hands off to","stack.redo.banner.relation.handoff.body":"A typed artefact crosses from one responsibility owner to another.","stack.redo.banner.relation.handoff.state":"contract edge","stack.redo.close.eyebrow":"Inspect the next layer","stack.redo.close.products":"Open the product index","stack.redo.close.foundations":"Open the foundations","stack.redo.close.trace":"Inspect a trace","stack.6458efb937":"Open the set","stack.f16ff8f0a4":"you actually need","stack.205eda38a0":"Move from the map","stack.973fee00ae":"to accountable detail","stack.e30636bf9a":"Inspect the contract","stack.3c82b1a92b":"at its source","stack.b4cd2038cf":"The counting rule stays explicit","stack.redo.side.sets.evidenceFooter":"Each set is counted from its own record","stack-showcase.e3dd034bb8":"Architecture, Stack","stack-showcase.6d917c2df3":"CORE","stack-showcase.47752e2b04":"OSS","stack-showcase.e72af43a28":"Evidence returns","stack-showcase.5b5aafe6b9":"Work flows in","stack-showcase.d7e2bd833c":"Responsibilities mapped","stack-showcase.42428b4e0c":"Five responsibility areas identify the work owner, the products involved, and the contract at each boundary. Mesh surrounds them as the policy for where that work may run.","stack-showcase.9bdc9133f5":"One system, five explicit responsibilities","stack-showcase.b040b4179b":"Architecture","stack-showcase.d5f412e831":"Kera","stack-showcase.68836c550e":"Core","stack-showcase.af0854de67":"Aura","stack-showcase.485a04fef4":"Nexus","stack-showcase.4a86080d67":"Spindle","stack-showcase.a010de5c61":"Fabric","stack-showcase.873132a799":"Mesh","stack-showcase.9ac0a89fc4":"Proof roots use BLAKE3 and Ed25519 and can be verified offline.","stack-showcase.66c95e7fc7":"Offline-verifiable","stack-showcase.126dfbce06":"Pinned inputs and graph hash reproduce the same result on supported targets.","stack-showcase.87e1309154":"Reproducible","stack-showcase.b4113daaa4":"HE, SMPC, and ZKP are available in paths that handle customer data.","stack-showcase.237dfa0a21":"Private","stack-showcase.e5dac54890":"Public contracts let one responsibility change without rewriting unrelated products.","stack-showcase.c8c0ef2b65":"Replaceable","stack-showcase.b70a8c41b5":"Eight foundations expose source code, and the proof format is public.","stack-showcase.cf9b77061f":"Inspectable","stack-showcase.a851b052ec":"The trace records source, rule, owner, and replay path for each decision.","stack-showcase.45ac82f360":"Auditable","stack-showcase.865048f4cc":"Loom records the constraint graph and specialist routing used to form a result.","stack-showcase.20690c0420":"Traceable reasoning","stack-showcase.2eead1feca":"The execution foundations target x86, ARM, RISC-V, and FPGA without a custom accelerator.","stack-showcase.1bacaf21b2":"Portable","stack-showcase.91ac9347d7":"The measured binary-compute workload used 96% less energy than its GPU baseline.","stack-showcase.76eeaec1cc":"Efficient","stack-showcase.176563051d":"Customer data can remain under EU jurisdiction with no foreign hot-path dependency.","stack-showcase.65cfa78989":"Sovereign","stack-showcase.cdee9a6e20":"Pinned inputs and a selected target reproduce identical bytes on repeated builds.","stack-showcase.f6798670ec":"Deterministic","stack-showcase.b76ab65957":"Hardware","stack-showcase.ba8ac97e12":"Silicon","stack-showcase.cd84197771":"Numerus","stack-showcase.3edf0df499":"Math","stack-showcase.188fb5d6cf":"Reed","stack-showcase.341a20e237":"Compiler","stack-showcase.68f4127b67":"Compute","stack-showcase.c91597c8b9":"BitWeave","stack-showcase.01335793c7":"Retrieval","stack-showcase.df84637182":"AION","stack-showcase.03f923bd0d":"Lattice","stack-showcase.bb9cf14180":"Policy","stack-showcase.6f45a48a1f":"Twin","stack-showcase.a725020675":"State","stack-showcase.0fed3b96cc":"Loom","stack-showcase.68c2cc7f0c":"Model","stack-showcase.64acf7e2a7":"Agents","stack-showcase.dec1fccaba":"Knowledge","stack-showcase.7b4db7ef1f":"Interface","stack-showcase.53ebc572b4":"Network","stack-showcase.product.charter":"Charter","stack-showcase.chrome.meta":"5 responsibility areas","stack-showcase.chrome.path":"Stack overview","stack-showcase.band.0.name":"Work and interface","stack-showcase.band.0.role":"Turns human intent into an owned, governed work object","stack-showcase.band.0.contract":"intent + context → work object","stack-showcase.band.1.name":"Coordination and knowledge","stack-showcase.band.1.role":"Assigns actors and tools, then supplies versioned knowledge","stack-showcase.band.1.contract":"work object → supervised plan","stack-showcase.band.2.name":"Reasoning","stack-showcase.band.2.role":"Selects specialists and carries constraints through the graph","stack-showcase.band.2.contract":"constraint graph → result + trace","stack-showcase.band.3.name":"State, policy, and evidence","stack-showcase.band.3.role":"Retrieves meaning, enforces policy, and records replayable state","stack-showcase.band.3.contract":"events + policy → state + proof","stack-showcase.band.4.name":"Execution foundations","stack-showcase.band.4.role":"Compiles typed graphs and executes them on the selected target","stack-showcase.band.4.contract":"typed graph → execution result","stack-showcase.mesh.name":"Mesh placement envelope","stack-showcase.mesh.body":"Constrains where the five responsibilities may run","stack-showcase.mesh.scope":"device · private cluster · European region","stk-hero-glyph.c09d8c4d28":"DEPENDENCIES EXPLICIT","stk-hero-glyph.b78d53363b":"Five responsibilities, named contracts, one placement policy","stk-hero-glyph.c83ee7779d":"THE STACK","stk-hero-glyph.ab216bc534":"EU x86, ARM","stk-hero-glyph.ba8ac97e12":"Silicon","stk-hero-glyph.cd84197771":"Numerus","stk-hero-glyph.98daa376d4":"Reed, Kera","stk-hero-glyph.68836c550e":"Core","stk-hero-glyph.c91597c8b9":"BitWeave","stk-hero-glyph.4eed34190a":"Lattice, AION","stk-hero-glyph.6f45a48a1f":"Twin","stk-hero-glyph.0fed3b96cc":"Loom","stk-hero-glyph.8e29441852":"Nexus, Aura","stk-hero-glyph.4a86080d67":"Spindle","stk-hero-glyph.a010de5c61":"Fabric","stk-hero-glyph.873132a799":"Mesh","stk-hero-glyph.2e4b088d8f":"Fabric, Charter","stk-hero-glyph.title":"System cross-section","stk-hero-glyph.status":"Contracts named","stk-hero-glyph.envelope.name":"Mesh placement envelope","stk-hero-glyph.envelope.body":"One policy for where the five responsibilities may run","stk-hero-glyph.envelope.scope":"device · private · European region","stk-hero-glyph.band.0.name":"Work and interface","stk-hero-glyph.band.0.handoff":"intent + context → work object","stk-hero-glyph.band.1.name":"Coordination and knowledge","stk-hero-glyph.band.1.handoff":"work object → supervised plan","stk-hero-glyph.band.2.name":"Reasoning","stk-hero-glyph.band.2.handoff":"constraint graph → result + trace","stk-hero-glyph.band.3.name":"State, policy, and evidence","stk-hero-glyph.band.3.handoff":"events + policy → state + proof","stk-hero-glyph.band.4.name":"Execution foundations","stk-hero-glyph.band.4.handoff":"typed graph → execution result","stk-hero-glyph.foot.label":"Boundary rule","stk-hero-glyph.foot.value":"Typed input · explicit output · preserved invariant"}