{"aura-ask-grid.af0854de67":"Aura","aura-business-sides.a0853da24b":"Spec sheet","aura-business-visuals.40417391c5":"Aura · resolves","aura-business-visuals.271973aefe":"xMidYMid meet","aura-business-visuals.3e91add48a":"BOARD","aura-showcase.eyebrow":"Dweve platform","aura-showcase.subtitle":"Coding agent and operator assistance. Demo metrics are illustrative.","aura-showcase.pillTools":"25+ tools","aura-showcase.pillRunning":"running","aura-showcase.pillAnalysing":"analysing codebase","aura-showcase.capabilityToolsTitle":"25+ tools","aura-showcase.capabilityToolsBody":"Terminal, search, lint, test, git, and more.","aura-showcase.capabilityMemoryTitle":"Semantic memory","aura-showcase.capabilityMemoryBody":"Remembers your codebase and team context.","aura-showcase.capabilityAgentsTitle":"Multi-agent orchestration","aura-showcase.capabilityAgentsBody":"Specialised agents collaborate across concerns.","aura-showcase.guaranteeAuditTitle":"Audit trail","aura-showcase.guaranteeAuditBody":"Every step is recorded with timestamps.","aura-showcase.guaranteeGuardrailsTitle":"Guardrails","aura-showcase.guaranteeGuardrailsBody":"Policies, checks, and tests always run.","aura-showcase.guaranteeApprovalTitle":"Code changes with approval","aura-showcase.guaranteeApprovalBody":"Review diffs, request changes, final sign-off.","aura-showcase.guaranteeReplayTitle":"Deterministic replay","aura-showcase.guaranteeReplayBody":"Replay any session bit-for-bit when something needs review.","aura-showcase.workflowUnderstand":"Understand","aura-showcase.workflowUnderstandCaption":"Read retry.ts, traced timeout bug","aura-showcase.workflowPlan":"Plan","aura-showcase.workflowPlanCaption":"Extract guard + cap retries","aura-showcase.workflowImplement":"Implement","aura-showcase.workflowImplementCaption":"Patched retry.ts + types.ts","aura-showcase.workflowTest":"Test","aura-showcase.workflowTestCaption":"28 tests, 94% coverage","aura-showcase.workflowVerify":"Verify","aura-showcase.workflowVerifyCaption":"Running lint & typecheck...","aura-showcase.workflowAudit":"Audit","aura-showcase.workflowAuditCaption":"Awaiting summary write-up","aura-showcase.footer":"Autonomous agents that write code and keep receipts","aura-showcase.testsPassing":"passing","aura-showcase.testsFailing":"failing","aura-showcase.modified":"modified","aura-showcase.af0854de67":"Aura","aura-showcase.73989d9c59":"Running","aura-showcase.f9e94338d0":"Analyzing codebase","aura-showcase.d7a484140f":"Workflow","aura-showcase.287fda8114":"Unified","aura-showcase.80e13549b4":"Coverage","aura-showcase.b71cc78b34":"Extracted isRetryableError","aura-showcase.c37a8a9e2b":"to handle\n                    network timeouts, 5xx responses, and idempotent-safe\n                    conditions. Pure helper, fully unit-tested.","aura-tech-middles.7fba7d244f":"Hot path","aura-tech-middles.1be47ef71c":"Cross-cutting","aura-tech-middles.92096d78df":"Ingress","aura-tech-middles.8e05a902ed":"Egress","aura-tech-middles.49a66c994d":"Builtin agents","aura-tech-middles.a60792e996":"Outer loop","aura-tech-middles.0dfd4db698":"Inner loop","aura-tech-middles.bbd88bff92":"Incoming request","aura-tech-middles.a618b4be8d":"Query","aura-tech-middles.a4942c26d0":"SELECT","aura-tech-middles.2cb479aa15":"* FROM","aura-tech-middles.1c255b91e7":"WHERE","aura-tech-middles.2164bde64d":"ORDER BY","aura-tech-middles.82dd2cdf36":"Block","aura-tech-middles.271973aefe":"xMidYMid meet","compare-table.ad565d9d01":"Feature","compare-table.65de2e2a3b":"Partial","core-backend-grid.28419bbb4d":"x86 legacy floor","core-backend-grid.8801365b4f":"128 bit vectors","core-backend-grid.30d11be033":"x86 stable mainline","core-backend-grid.789796a624":"256 bit vectors","core-backend-grid.a94df02c9a":"VPOPCNTDQ binary popcount","core-backend-grid.669cde252c":"512 bit per instruction","core-backend-grid.5f305d0313":"NEON","core-backend-grid.55abb26f4f":"ARM and Apple silicon","core-backend-grid.45ad5b64df":"NEON popcount","core-backend-grid.3d49729349":"Scalable ARM vectors","core-backend-grid.ed53046b80":"Length agnostic","core-backend-grid.7b8cb98313":"Scalar","core-backend-grid.b80f0959bf":"Reference and hard determinism target","core-backend-grid.30cffca5a7":"Always present","core-backend-grid.ae4b69630a":"CUDA","core-backend-grid.088472395b":"NVIDIA","core-backend-grid.80df4ac0a6":"Warp shuffles","core-backend-grid.0da0b5b2d3":"ROCm","core-backend-grid.dc1b9b4bb0":"AMD","core-backend-grid.710cb2ab33":"Wavefront ops","core-backend-grid.90acb40694":"Metal","core-backend-grid.c99f2d4eed":"Apple GPU","core-backend-grid.c92940c550":"Compute shaders","core-backend-grid.9663160126":"Vulkan","core-backend-grid.73e0c6ad73":"Cross vendor GPU","core-backend-grid.f5ffade173":"WebGPU","core-backend-grid.b79569bc8b":"Browser GPU","core-backend-grid.4e946026a7":"WASM","core-backend-grid.e4189ae626":"Browser CPU","core-backend-grid.684f532717":"WASM SIMD","core-backend-grid.cef7f9bd36":"FPGA","core-backend-grid.6675322f29":"Deployment target, synthesis scaffolding","core-backend-grid.139ed42413":"Native bit ops","core-backend-grid.ff221d4752":"CPU","core-backend-grid.a6a6318544":"GPU","core-backend-grid.a8323a2a9b":"Web","core-backend-grid.fb4192a0d1":"Deploy","core-backend-grid.89d1921d60":"12 targets resolved","core-backend-grid.46bf034dc8":"scalar fallback always","core-backend-grid.f8af510ee4":"Abstract operator","core-backend-grid.69b65798fc":"Runtime dispatcher, picks per call by target and policy","core-backend-grid.34544c0fd0":"One operator definition, hand tuned kernels per ISA. If your silicon shipped in the last\n          eight years, Core has a path to it.","core-business-glyph.c82d1b09cf":"EU","core-business-glyph.110547d86d":"Capability and determinism stated per cell","core-business-glyph.4c03eada21":"Quantisation pipeline","core-business-glyph.bfe06577c0":"Direct operation on customer-controlled infrastructure","core-business-glyph.ecea9c9372":"Dweve Core","core-business-glyph.b9422ffe1f":"One complete AI machine","core-business-glyph.79ba5e1b3f":"After","core-business-glyph.44cf0e38a0":"One model, several supplier-held paths","core-business-glyph.772a705714":"A fragmented stack","core-business-glyph.74f39697ac":"Before","core-business-glyph.b3fc8bebf4":"One machine","core-business-glyph.07841289ee":"Operations review","core-business-glyph.a92831c31f":"Built in the Netherlands","core-business-glyph.0494033f67":"Customer-controlled operation","core-business-glyph.0d4dc7b340":"Isolated estates supported","core-business-glyph.d96159ff30":"Determinism contracts","core-business-glyph.a1fdaa6b2a":"Operations","core-business-glyph.383370f354":"Capability states","core-business-glyph.aa50825f45":"Registered format families","core-business-glyph.e5a4c8ca8f":"compression lives in another tool","core-business-glyph.ae4b69630a":"Accelerator runtime","core-business-glyph.1e56dfbac5":"no kernel gets chosen","core-business-glyph.5fe290c1c4":"the numbers stop resolving","core-business-glyph.148fb3e1f0":"Numerical library","core-business-glyph.7d53e71273":"the definition and execution slowly disagree","core-business-glyph.98a2e30eeb":"Model framework","core-compiler-pipeline.b644360e45":"One operator surface across the framework, the engine, and the compiler. No external glue.","core-compiler-pipeline.289e498918":"any target","core-compiler-pipeline.924c834535":"Native code","core-compiler-pipeline.2105179648":"Kera IR","core-compiler-pipeline.d78e3b4097":"your model","core-compiler-pipeline.4cf33dd11e":"Neural graph","core-compiler-pipeline.11ed56f704":"graph to native","core-compiler-pipeline.7f679d34ae":"three in one, on Kera","core-compiler-pipeline.324b28c099":"Core runs on Kera, a deterministic intermediate representation. Kera is the IR itself, not a wrapper around MLIR and not built on LLVM. Multi level lowering takes a neural graph down to hardware specific native code with fusion.","core-compiler-pipeline.3a130d8a09":"Lower to the target","core-compiler-pipeline.341a20e237":"Compiler","core-compiler-pipeline.67e9b4bdf7":"A complete training engine with quantisation aware training, knowledge distillation, progressive precision, and distributed training. The inference engine ships three determinism modes and production serving.","core-compiler-pipeline.d1211e546b":"Train and run it","core-compiler-pipeline.c1f65ddb75":"Engine","core-compiler-pipeline.79b41e355f":"A type safe DSL for any architecture and any bit width. Compose from primitives or from existing layers, and add your own with the same testing infrastructure as the built ins.","core-compiler-pipeline.a6efc62456":"Author the model","core-compiler-pipeline.fb001b2c29":"Framework","core-compiler-pipeline.point.e601e75348":"Or native Rust kernels per runtime","core-compiler-pipeline.point.5ceb39b24b":"Multi level lowering with fusion","core-compiler-pipeline.point.f2111d5e47":"QAT, distillation, distributed","core-compiler-pipeline.point.718a332ac6":"Kera is the IR, deterministic","core-compiler-pipeline.point.c3e1e4f561":"Custom ops, same test harness","core-compiler-pipeline.point.98fc8e119a":"Any data type, any bit width","core-compiler-pipeline.point.755f118b12":"Type safe model authoring","core-compiler-pipeline.point.7cd06dba33":"Three determinism modes","core-compiler-pipeline.point.eb60d5e115":"ONNX import and export","core-consumer-glyph.6ff4def81b":"Made in Europe, by Dweve","core-consumer-glyph.6399d86459":"Runs on ordinary computers, where supported","core-consumer-glyph.3657360270":"quietly humming along","core-consumer-glyph.d257b8d202":"The engine under everything","core-consumer-glyph.c9e03ad33d":"It can show how it got there.","core-consumer-glyph.640a7da7c7":"Honest answers","core-consumer-glyph.406a67437f":"Can work offline, where supported.","core-consumer-glyph.14c6ece207":"Works offline","core-consumer-glyph.bc44dc107a":"Your things can stay home, in Europe.","core-consumer-glyph.5d1b6753c5":"Stays with you","core-consumer-glyph.c6bb6d4850":"No special computer to buy.","core-consumer-glyph.1eaf8917fa":"Your laptop","core-deploy-postures.29c178eb3e":"A proof started through managed Fabric can inform a later transition to licensed Core operation, including a physically isolated licensed estate. Managed Fabric itself does not include Core.","core-deploy-postures.5374777438":"What can transfer across the adoption path","core-deploy-postures.e2ed2a98c5":"one proof path, two licensed operating postures","core-deploy-postures.9738e29dbc":"where it runs","core-deploy-postures.c5d23bb6c3":"Data duties stated for each posture","core-deploy-postures.b2d96de930":"Portable evidence concepts","core-deploy-postures.7eacdbe1cf":"Controlled transition plan","core-deploy-postures.6ada774b6a":"Familiar review concepts","core-deploy-postures.bcb561842d":"Transfer rights only where contracted","core-deploy-postures.08929ccc28":"No outbound connections","core-deploy-postures.d8a6da1592":"A physically isolated licensed deployment for environments that cannot tolerate an external connection. Technology-transfer and independence rights are available only where the selected Government and Critical Infrastructure tier states them.","core-deploy-postures.59a081f5e2":"No outbound dependency","core-deploy-postures.ce76922463":"Physically isolated","core-deploy-postures.a0f5058b8c":"Source escrow priced separately","core-deploy-postures.99d4d43cd5":"Your servers, your operators","core-deploy-postures.5e954f3085":"Operate licensed Core on your own servers in your own data centre. Your operators hold the keys; source escrow and source rights remain separate unless the agreement expressly includes them.","core-deploy-postures.4bb1272b51":"Your hardware, your keys","core-deploy-postures.3beac38f40":"On your premises","core-deploy-postures.a1d431a4f7":"No hardware project to start","core-deploy-postures.42cc65f880":"Built in the Netherlands; operating boundary stated in the agreement","core-deploy-postures.30546c0389":"Managed Fabric is a separate service on the public Mesh and does not include Core access or Core operation. Direct Core operation begins with a licence for customer-controlled infrastructure.","core-deploy-postures.8258e2ff73":"Ready on day one","core-deploy-postures.76b0fd5a1b":"Managed Fabric proof, no Core access","core-determinism-console.1043858aa3":"Determinism is a setting, not an aspiration. The test suite asserts it, it is not promised in prose.","core-determinism-console.430f69dd34":"Switch per request, no re-deploy.","core-determinism-console.619f51e736":"Determinism modes","core-determinism-console.a18de17231":"one dispatch, three modes","core-determinism-console.6909d6900b":"determinism: relaxed by request","core-determinism-console.95b29a727e":"dispatch: same integer/fixed model in every mode","core-determinism-console.88ca38dd6a":"sampling: temperature 0.8, top p 0.95","core-determinism-console.ae57883db7":"core.infer(model, x, determinism=\"creative\", temp=0.8)","core-determinism-console.10d30eb322":"Full non determinism where desired. Temperature, top k, and top p sampling. The same dispatch model with determinism relaxed, no separate code path.","core-determinism-console.20ccbc66c1":"Creative","core-determinism-console.4ae06b36f2":"reproducible: yes, per seed","core-determinism-console.6406685834":"variance: bounded, controlled","core-determinism-console.7d2c426ea8":"seed: 42, same seed gives same output","core-determinism-console.7e3a31d0df":"core.infer(model, x, determinism=\"seeded\", seed=42)","core-determinism-console.337ba21821":"Reproducible given the same seed, different seeds produce different outputs. Useful for A/B testing, Monte Carlo runs, and any workflow where controlled variation is wanted.","core-determinism-console.28caa2e08a":"A/B safe","core-determinism-console.51095bb5db":"Seeded","core-determinism-console.1cfd991cd8":"output hash: stable on every target","core-determinism-console.a62c2f9714":"replay: bit identical across ISA","core-determinism-console.bf753ed3b5":"route: exact arithmetic (Numerus)","core-determinism-console.44a56d6b4a":"core.infer(model, x, determinism=\"hard\")","core-determinism-console.9ea9f443a7":"Routes through declared integer and fixed-point arithmetic, removing platform-dependent arithmetic drift. Bit-identical outputs across supported targets. The mode used when a contract or regulator requires reproducibility.","core-determinism-console.51f7c88c7e":"audit default","core-determinism-console.20a89915f1":"Hard","core-engine-explainer.c26fa20390":"It sips power","core-engine-explainer.a9a0d7297f":"Core does its sums in a simpler, lighter way than most AI. So it does not need a room full of hungry chips. The computer you already own is enough.","core-engine-explainer.21e6ca252a":"Runs on a normal laptop","core-engine-explainer.97d07244f5":"EFFICIENT","core-engine-explainer.e9ee99ac31":"It stays with you","core-engine-explainer.0d28f10463":"Because it runs on your own machine, your questions and documents do not have to travel to a far away company. What you type stays where you can see it.","core-engine-explainer.e07f4856e2":"Your words stay home","core-engine-explainer.b0b7ba4666":"PRIVATE","core-engine-explainer.3356cb70a8":"It shows its working","core-engine-explainer.46f9c77546":"When Core gives you an answer, it can show the steps it took to get there, like a maths teacher writing out the sum. You never have to take it on faith.","core-engine-explainer.991d9a4959":"Every answer is checkable","core-engine-explainer.fe453a5f12":"HONEST","core-engine-explainer.aa05f433cb":"the engine, in plain words","core-engine-explainer.18a7efb737":"running quietly","core-engine-explainer.8baa22b1b5":"Think of Core as the","core-engine-explainer.eeff56077d":"engine in a car","core-engine-explainer.a2d795d609":"You never touch the engine. But everything you feel, the speed, the smoothness, the\n            quiet, comes from how well it was built. Most AI is built from engines bought off the\n            shelf. Dweve built its own, so it runs well on ordinary computers and keeps your things\n            with you.","core-engine-explainer.1eaf8917fa":"Your laptop","core-engine-explainer.b9d79aee82":"Core, the engine","core-engine-explainer.338de642e9":"An answer you trust","core-engine-explainer.723a298b99":"Why it feels different","core-engine-explainer.af4b9ee8eb":"Core, the quiet engine under every Dweve product","core-everyday-grid.011979d948":"Simple to use, kind to your wallet, and yours to keep","core-everyday-grid.b53968b90f":"six plain reasons","core-everyday-grid.8b9b9baa3b":"what it means for you","core-everyday-grid.83c50f4d81":"Dweve is built in the Netherlands by people who answer to European law. There is a real company and a real place behind the engine you are using.","core-everyday-grid.22c2234e11":"Made in Europe","core-everyday-grid.eef6f15153":"It uses far less electricity than the AI that needs huge machines. That keeps the price low and means a free version can exist at all.","core-everyday-grid.8caa318cf5":"Cheap to run","core-everyday-grid.bd2e42d365":"When it tells you something, it can show you how it got there, step by step. If it is ever unsure, it says so, instead of guessing and hoping.","core-everyday-grid.b15cdbe75b":"You can check the answer","core-everyday-grid.633182038f":"Because the engine lives on your own device, it keeps working even when the connection drops. Like a calculator, it does not need to phone anyone to do its job.","core-everyday-grid.6c7ac2123a":"Works without the internet","core-everyday-grid.75467599a2":"Your letters, photos and questions do not get shipped off to a faraway computer. They stay with you, in Europe, under European rules.","core-everyday-grid.ffa30cc1d7":"Your things stay yours","core-everyday-grid.fa7b8dfe8c":"You do not need to buy anything new or expensive. If your laptop can show you a video, it can run Dweve. The clever part is built into the engine, not into a costly machine.","core-everyday-grid.a92afb395d":"No special computer","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","core-hero-glyph.7e35cbabb1":"model.dsl, type-safe authoring","core-hero-glyph.921fa5fef1":"dispatch resolved, kernel named","core-hero-glyph.72966a355b":"QAT, AdamW, epoch 30/30","core-hero-glyph.5f2b28c23a":"distilled to a 1-bit student","core-hero-glyph.8006901168":"avx512.vpopcntdq, 512-bit lanes","core-hero-glyph.9ca9362675":"execution cell and replay contract recorded","core-hero-glyph.66639f7d45":"Binary","core-hero-glyph.5a6d2663ae":"1-bit, XNOR","core-hero-glyph.9edcffff44":"Integer","core-hero-glyph.f827f806fb":"Int2 to Int64","core-hero-glyph.ab98f5b857":"Fixed","core-hero-glyph.a53e0dae8d":"Q1.6 to Q127.128","core-hero-glyph.45d3120822":"Bfloat and scaled","core-hero-glyph.3ad190077c":"block-scaled and microscaled","core-hero-glyph.64435fd82d":"Conventional float","core-hero-glyph.0ef533dfef":"FP8 through FP64","core-hero-glyph.fb001b2c29":"Framework","core-hero-glyph.c1f65ddb75":"Engine","core-hero-glyph.886fbe7e58":"train, serve","core-hero-glyph.341a20e237":"Compiler","core-hero-glyph.9b756654f9":"x86_64 avx512","core-hero-glyph.a7cb01023f":"Dweve Core [v1.0.0]","core-hero-glyph.20c7c5522f":"Ready","core-hero-glyph.e2103ef9f9":"complete AI compute stack","core-hero-glyph.81b16c1ba6":"Core Native foundation, Rust","core-hero-glyph.e88aa8b0c0":"BinaryLLM::builder()","core-hero-glyph.bbbb5c5b13":".precision(Binary).backend(Auto).build()","core-hero-glyph.d60bd4ce3c":"numeric formats","core-hero-glyph.5d5c2d3211":"One toolkit","core-hero-glyph.7a39156a34":"12 target families, scalar reference","core-hero-glyph.bee831a169":"Substrate","core-hero-glyph.a1fdaa6b2a":"Operations","core-hero-glyph.2804d9f16a":"Formats","core-hero-glyph.3dd4db5ce7":"Precision","core-hero-glyph.f433899bfa":"binary to conventional float","core-hero-glyph.437bcb1511":"Energy","core-hero-glyph.5902e88c6f":"right-sized per task","core-hero-glyph.275e494e92":"core build --release","core-hero-glyph.a06a582e9d":"PURE CORE NATIVE","core-hero-glyph.f728176786":"12 backend families","core-hero-glyph.b7b6b08941":"Rust, Python","core-hero-glyph.d5f412e831":"Kera","core-hero-glyph.8d784dbff4":"IR","core-hero-glyph.fe06eb6459":"Tab","core-middles.7c9a7c0610":"Detail","core-middles.79fd1355be":"Capability","core-middles.4db98af9e3":"Replaced by","core-middles.d09b744d4c":"Today’s stack","core-outcome-board.dd5897e441":"Core changes the substrate, not the interface you already know.","core-outcome-board.ecea9c9372":"Dweve Core","core-outcome-board.0d2ba685c7":"The usual GPU stack","core-outcome-board.229d54d49e":"one substrate changes all four","core-outcome-board.b83b6fcaeb":"four counts compared","core-outcome-board.d4f78d0814":"side by side","core-outcome-board.e888ae98e3":"Replayable by design","core-outcome-board.ab3a5efee1":"Hard determinism replays a result bit for bit, on demand.","core-outcome-board.f5196f5270":"Compliance is assembled after the hard questions arrive.","core-outcome-board.33de865a8d":"Audit trail","core-outcome-board.03808c4a87":"European by construction","core-outcome-board.d4f047c94f":"EU only data paths, built and run from the Netherlands.","core-outcome-board.df74dc9154":"Data lands on a foreign hyperscaler under foreign law.","core-outcome-board.5d1cc3c5c6":"Jurisdiction","core-outcome-board.a268e26994":"96% less energy","core-outcome-board.dc2611a7ef":"96% less energy than a GPU stack, the same answers at a fraction of the running cost.","core-outcome-board.14cde65f55":"A generative GPU stack draws power by the megawatt.","core-outcome-board.437bcb1511":"Energy","core-outcome-board.df25122e42":"No procurement cycle","core-outcome-board.c8839bbfc0":"CPU first, on servers you already own.","core-outcome-board.92009bd04d":"GPU clusters you bid for against hyperscalers.","core-outcome-board.b76ab65957":"Hardware","core-precision-spectrum.263290aaa2":"1 to 2 bit","core-precision-spectrum.9132883f83":"Binary and ternary","core-precision-spectrum.45c12b92c8":"Packed bits, {-1, 0, +1}","core-precision-spectrum.d808ff50f2":"Int16 or Int32","core-precision-spectrum.201e6efbd6":"XNOR + POPCNT, bit matmul","core-precision-spectrum.aaf819444d":"Edge and low bit research. Part of the 96% less energy story.","core-precision-spectrum.2b968cd0cd":"2 to 8 bit","core-precision-spectrum.49014cc718":"Integer and fixed point","core-precision-spectrum.1c957b17ad":"Int2, Int4, Int8, Q1.6 to Q127.128","core-precision-spectrum.f4753a4dee":"Int32","core-precision-spectrum.0c2128c018":"Quantised GEMM, Q-notation, bit plane","core-precision-spectrum.4f63826b55":"Quantised inference and deterministic fixed point.","core-precision-spectrum.0bf2ba3f0b":"8 to 16 bit","core-precision-spectrum.1da3862358":"Adaptive fixed point","core-precision-spectrum.0ea6a3e3d7":"Q8.8, Q12.4, per-group integer scale","core-precision-spectrum.91be0f9517":"Adaptive integer GEMM","core-precision-spectrum.d538378ee5":"Internal training and accuracy-sensitive layers.","core-precision-spectrum.ed53858f8c":"32 to 64 bit","core-precision-spectrum.0ce3a3e995":"Wide fixed and exact","core-precision-spectrum.0ef533dfef":"Q31.32, Q63.64","core-precision-spectrum.ab15483521":"wide fixed point or exact via Numerus","core-precision-spectrum.702f4ecaf1":"Exact arithmetic routing","core-precision-spectrum.f475bf8ba6":"Determinism contracts and reference checks.","core-precision-spectrum.b9c8c2f62d":"25 numerical families, no internal FP path","core-precision-spectrum.9f87638733":"storage != accumulator","core-precision-spectrum.9e092dda4f":"Storage","core-precision-spectrum.c47d1e40dc":"Accumulator","core-precision-spectrum.d5617d27c9":"Kernels","core-precision-spectrum.79185beb20":"Use case","core-precision-spectrum.a496a5978a":"Choose internal storage, accumulator, and dispatch policy per operator. External floating input converts at the boundary before the compiler lowers the mix to the target.","core-precision-spectrum.0994283f22":"Every internal representation is a first-class citizen, baked into the operator rather than configured after the fact.","core-precision-spectrum.fdd021a46a":"binary to adaptive fixed","core-stack-replacer.5d72c83534":"Built on Kera, deterministic by design","core-stack-replacer.14ff506396":"The same work, done by one engine you own, instead of a pile of vendor tools glued together.","core-stack-replacer.30e9fdb050":"Framework, engine, and compiler in one","core-stack-replacer.ecea9c9372":"Dweve Core","core-stack-replacer.9ab7d0b644":"With Dweve Core","core-stack-replacer.eaa082ced6":"Five upgrade cycles, five security surfaces, five places it can break.","core-stack-replacer.9634869d88":"Your stack today","core-stack-replacer.8a887faa8c":"one accountable vendor","core-stack-replacer.6d0ed26dcb":"5+ tools, replaced by 1","core-stack-replacer.7dc5dd46fe":"stack consolidation","core-stack-replacer.5ece93d530":"Every result can be replayed and checked.","core-stack-replacer.90045a604c":"Auditable by construction","core-stack-replacer.4b0752aa34":"Data stays in Europe, on infrastructure you control.","core-stack-replacer.0d4dc7b340":"GDPR by design","core-stack-replacer.084ec1799f":"No GPU procurement, no hyperscaler bidding war.","core-stack-replacer.1f4829404a":"Runs on servers you own","core-stack-replacer.c6658e7d64":"One contract, one support line, one upgrade cycle.","core-stack-replacer.e5ca29bede":"One vendor accountable","core-stack-replacer.08e1de63e8":"Glue code","core-stack-replacer.a1632dbce6":"Quantisers","core-stack-replacer.6b57120d9f":"ONNX tools","core-stack-replacer.ae4b69630a":"CUDA","core-stack-replacer.148fb3e1f0":"NumPy","core-stack-replacer.98a2e30eeb":"PyTorch","page-breadcrumb.c766e66518":"Breadcrumb","page-toc.7e439c353e":"On this page","product-core.e2ae20d9ae":"Rust","product-core.6e3604888c":"Python","product-core.b95944cf8b":"Core, engineering","product-core.20ccbc66c1":"Pure Core on Kera","product-core.f9743247fa":"Read the documentation","product-core.51095bb5db":"Seeded Core Native","product-core.20a89915f1":"Pure Core Native","product-core.199e776d2c":"PURE ON KERA","product-core.7b2513bac6":"SEEDED FLOAT","product-core.a06a582e9d":"PURE NATIVE","product-core.20289a428e":"Inference engine","product-core.0b916629af":"Storage format is not accumulator type","product-core.9132883f83":"Binary and ternary","product-core.a7e44d0843":"Backend targets","product-core.769357157b":"Numeric formats","product-core.fce42136e9":"Fixed-point","product-core.287621e2bd":"76 CATEGORIES","product-core.67c0805d6b":"2,900+ OPERATIONS","product-core.16dd3a5175":"Progressive precision","product-core.63deca910c":"Trainer","product-core.a1fdaa6b2a":"Operations","product-core.0ac44a1447":"2,900+ across 76 categories","product-core.327a55f82d":"Deployment","product-core.6af74613cf":"Built in Europe","product-core.4a86080d67":"Spindle","product-core.485a04fef4":"Nexus","product-core.0fed3b96cc":"Loom","product-core.48cd18dabc":"Your data","product-core.a010de5c61":"Fabric","product-core.68836c550e":"Core","product-core.fe0a091fdb":"Products","product-core.8c105a0922":"Dweve Core, the complete AI machine","product-core.f147a72faf":"Dweve built the whole machine","product-core.0e981ffcec":"underneath AI","product-core.d2a23ae7f7":"Dweve Core is a complete AI compute stack for training and inference. Most AI platforms cover a slice and hand the rest to other vendors. Core keeps model authoring, training, inference, kernels, dispatch and deployment in one coherent system. On supported binary workloads, Core uses 96% less energy than a GPU stack.","product-core.da4a6496f4":"See what coverage means","product-core.90214883b6":"Talk to us","product-core.50d50d930a":"The implemented machine","product-core.d7657a2d2e":"COVERED","product-core.7397c035e7":"25 registered numerical format families","product-core.1328312aa9":"12 backend target families","product-core.59900d07c9":"Implementations","product-core.0f07eee169":"around 408K, hand-tuned","product-core.fd61c5e2a2":"96%","product-core.83298d25e6":"less energy than a GPU stack","product-core.6863648b18":"On supported binary workloads.","product-core.b00503c674":"Execution foundations","product-core.71f8e7976e":"Core Native + Core on Kera","product-core.34a03b7e27":"Partial systems create permanent dependence","product-core.82acdea9d9":"The file is yours,","product-core.b917e77b63":"the stack is not","product-core.b0dcc14813":"OWNED ARTEFACT","product-core.8cd46966cc":"SUPPLIER STACK","product-core.8f27a7c87e":"THEIRS","product-core.7921747884":"GAPS COMPOUND","product-core.edcf9523bd":"Where the drift enters","product-core.7e7856ca60":"five familiar handovers","product-core.7be9875ef9":"Framework drift","product-core.9df4d65bb4":"The definition and the execution slowly disagree.","product-core.fd156c644a":"Quantisation handoff","product-core.6f0ca4dfaf":"Compression lives in someone else's tool.","product-core.13a075c914":"Runtime migration","product-core.3546ad8453":"New hardware, new serving system, new behaviour.","product-core.1206b26b69":"Accelerator lock","product-core.9bef5e9ee3":"The vendor's roadmap becomes your roadmap.","product-core.8afb820ddb":"Audit fragmentation","product-core.9427e1ad46":"No single system can explain the result.","product-core.8ceebd83d0":"the artefact is owned","product-core.513ffac9ec":"the operation is not","product-core.4f1e9acda7":"Dependence persists because the computational space underneath is only partially covered.","product-core.98fc5acbea":"Implementation is the strategic asset","product-core.198874754e":"Thousands of execution paths","product-core.eef0e3251d":"Core keeps changes in numerical width, packing, hardware and deployment inside one implementation system. An algorithm does not become a different product because it moves from an x86 server to ARM, a GPU, a browser or a specialised target. The operation remains named, inspectable and owned throughout the move, and every path is registered rather than inferred from a format label.","product-core.02fe20a477":"The implementation registry spans more than 2,900 operations, 76 operation categories and 25 registered numerical format families. Each path is determined across nine dimensions: algorithm, datatype, width, packing, accumulator, backend, instruction set, dispatch policy and determinism mode. The representation contract keeps those numerical and physical choices attached to the operation.\n\nThe visual below fixes most of those dimensions so a small representative slice remains readable. The count describes a registry of concrete cells and contracts, not a claim that a format label or broad capability badge alone explains an execution path.","product-core.17f64286ad":"OWNED REGISTRY","product-core.544880cdf9":"NINE DIMENSIONS","product-core.0456893757":"ONE SYSTEM","product-core.f62e149ac3":"The execution dimensions","product-core.d619b53c0b":"what actually determines a run","product-core.3111525fc0":"Algorithm and primitive","product-core.9b7ccfcd90":"What is being computed.","product-core.d7aece1b06":"Datatype and width","product-core.d3f255e763":"What carries it, at which precision.","product-core.b738e97c7b":"Packing and accumulator","product-core.3bf512876f":"How it is stored, how it is summed.","product-core.5e0ace38bb":"Backend and instruction set","product-core.cede572419":"Where it runs, on which real path.","product-core.b1de2e6350":"Dispatch and determinism","product-core.85108cb858":"Which path is chosen, under which contract.","product-core.56ccbf3637":"features are coordinates","product-core.9145e778aa":"the matrix is the asset","product-core.966a426d51":"The sample is small because the implementation registry is not.","product-core.d5a76c53ce":"One algorithm survives every constraint","product-core.14aa4787c1":"Change the condition,","product-core.e53081b053":"not the ownership","product-core.79d87dc6f5":"SAME ALGORITHM","product-core.36877e83b2":"NEW CONSTRAINT","product-core.f50f43301e":"ONE OWNER","product-core.5844e8c26a":"What a change triggers","product-core.0f7b66aa21":"inside Core, not across vendors","product-core.8b925e7f54":"Condition changes","product-core.b06c216be9":"A new width, packing, host, or contract arrives.","product-core.9a179fcfe0":"Operator contract holds","product-core.7f753c72b7":"The operation keeps its meaning.","product-core.19568c8813":"Kernel is reselected","product-core.62ba6aae0f":"The machine picks the path for the new cell.","product-core.a4d8e86776":"Dispatch is recorded","product-core.3de33b80a1":"Which code ran, on which machine, stated.","product-core.8e2e4938e5":"The model remains","product-core.67fbada1de":"Same asset, same owner, new condition.","product-core.de87d611c5":"constraints rotate","product-core.2c30d5143d":"responsibility does not","product-core.e0aa475c59":"The first inherited assumption Core removes is that one datatype should dominate everything.","product-core.a0ee3412ba":"No privileged datatype","product-core.05bcb567d0":"The work chooses","product-core.3d43793e52":"the representation","product-core.87b30414d7":"BINARY TO FLOAT","product-core.445d9dee45":"MIXED BY OP","product-core.0c7205b714":"NO FORMAT CENTRE","product-core.7e28cf393d":"The representation ladder","product-core.4aac49e8f5":"every rung is first-class","product-core.a54ec2a121":"no format is a fallback","product-core.10b75222e5":"no rung is a research feature","product-core.ea05cefbe3":"The processor should be just as replaceable as the datatype.","product-core.25f7fcb5e0":"No privileged processor","product-core.be26c3955a":"Hardware is a destination","product-core.717ca7bbbb":"for the operation","product-core.3359ea50ca":"Core does not treat one accelerator ecosystem as the definition of AI and everything else as a lesser port. Its operations have scalar reference implementations and target-specific paths across supported CPU, GPU, FPGA, browser, and deployment backends. The runtime selects an implementation according to the available machine and the policy attached to the work.","product-core.a826ede432":"A modern x86 processor can use its vector instructions. ARM and Apple silicon can use their native paths. NVIDIA, AMD, and Apple GPUs can use their respective backends.\n\nBrowser execution can use WebAssembly or WebGPU where appropriate. Deployment programmes can target specialised hardware. The processor is a destination for the operation. It is not the owner of the model.","product-core.ff886f5f45":"SCALAR FLOOR","product-core.29831008f0":"TARGET PATHS","product-core.879abeb654":"POLICY-AWARE","product-core.d4af42d25b":"Four families of destination","product-core.65141f503b":"siblings, not satellites","product-core.ff221d4752":"CPU","product-core.04894c32d7":"x86 vectors, ARM and Apple silicon native paths.","product-core.6f5b01580c":"native","product-core.a6a6318544":"GPU","product-core.35cc0baf6a":"NVIDIA, AMD, and Apple GPUs on their own backends.","product-core.f95b5fe233":"sibling","product-core.54a2cf5e63":"Browser","product-core.e3cac92a1f":"WebAssembly or WebGPU where appropriate.","product-core.939bb46a04":"local","product-core.3a9f261fe3":"Specialised hardware for deployment programmes.","product-core.0e8a3ad980":"target","product-core.f94f7fdfdb":"no central sun","product-core.28c5cd473f":"no degraded satellites","product-core.29d9540493":"Broad target labels are cheap. Owning the real path is harder.","product-core.bbdbbb57f7":"You have run this project","product-core.70b4b6f0fa":"The new AI requirement","product-core.banner.business.headlineAccent":"looked small.","product-core.6084d7d3bb":"The datatype was unsupported, the target hardware changed, and the quantiser needed another runtime.","product-core.d86a452254":"The serving stack could not replay the result. Procurement opened another supplier review.","product-core.c4b70b47cf":"Around one small requirement","product-core.29ca16fd06":"The datatype was unsupported","product-core.19f00e84cd":"The quantiser needed another runtime","product-core.d7dac23d19":"The result could not be replayed","product-core.f2f225a299":"Procurement opened another review","product-core.36b38b2e56":"You did not add one feature. You exposed another hole in the machine.","product-core.60cc267a6f":"Core, The Complete AI Machine","product-core.526130b0ff":"Hand-tuned means someone owns the result","product-core.d628269575":"Coverage is code,","product-core.9dff592837":"not a capability badge","product-core.75208753ab":"A broad API is easy to advertise. Broad machine-level ownership is much harder. Core does not count an operation as covered merely because a generic implementation compiles on another target. The supported paths are implemented and tuned for their actual combination of operation, representation, packing, backend, and instruction set.","product-core.20d50c23a5":"Binary matrix multiplication on AVX-512 is not treated as floating-point matrix multiplication with smaller values. Packed-bit operations use the bit instructions available to the machine. Integer and fixed-point operations use the correct accumulator and overflow behaviour.\n\nGPU paths use the execution structure of the target. Scalar implementations remain present as the reference and universal floor. That creates an accountable answer to a simple question: what code actually performed this operation on this machine? Core can name the path.","product-core.efe1c2f148":"CELL TUNED","product-core.1daab8478c":"SCALAR FLOOR","product-core.6ef809a467":"PATH NAMED","product-core.59b230b959":"What a covered cell owns","product-core.7c6d405f6a":"implementation, not aspiration","product-core.548b94b660":"The operation","product-core.4bfb7a3d7a":"Written for what is actually computed.","product-core.e534aa5c63":"The representation","product-core.84dfe47b52":"Bit instructions for bits, not scaled floats.","product-core.579e554464":"The accumulator","product-core.a94ebfb2b1":"Correct overflow behaviour, by design.","product-core.6305531fce":"The instruction set","product-core.3c2e065061":"NEON kernels written for ARM's own vector architecture.","product-core.46c8fe7c4d":"what code ran here?","product-core.83abfb9eb8":"Core can name it","product-core.a2604f177c":"That ownership must continue beyond the kernel and across the entire model lifecycle.","product-core.132d62a09b":"One machine from definition to inference","product-core.d4b31873bb":"No change of owner","product-core.669c4098ca":"halfway through","product-core.84789f2cc1":"AUTHOR TO RUN","product-core.217f153196":"NO EXPORT GLUE","product-core.23a7d6b04a":"ONE PASSPORT","product-core.95b5b6c8fb":"One lifecycle, one system","product-core.1d0854e923":"the stations the model never leaves","product-core.fb001b2c29":"Framework","product-core.03670bcde0":"The model is authored in Core terms.","product-core.3146e94d30":"Trained for the representation it will use.","product-core.254eb14985":"Executed by the system that trained it.","product-core.48f91366c8":"Dispatcher","product-core.eba0a83fe5":"Routed to the tuned path for the host.","product-core.e0264861a9":"Verifier","product-core.eb8e4c9808":"Benchmarked and replayed in the same machine.","product-core.434332eb3f":"imports and exports exist","product-core.7b794a9127":"as boundaries, not glue","product-core.f6baa7b9b9":"Once the lifecycle is coherent, variation can become a contract rather than an accident.","product-core.a42ca81f48":"Three honest determinism contracts","product-core.ccca1fdffc":"Pure where native,","product-core.93c2809a14":"pure floating where optional","product-core.2a983b9ece":"Core states the contract of the path that actually ran. Core Native binary, ternary, signed and unsigned integer, fixed-point, adaptive and exact paths are pure deterministic where covered, with no seed. Core Native floating, bfloat, block-scaled and microscaled paths use seeded replay. Optional Core on Kera makes supported paths in those floating families pure deterministic too.","product-core.6905f96c11":"A regulated low-bit, Q-format or adaptive workflow can demand bit-identical Core Native replay. A floating-family workflow can use a pinned seed and complete record under Core Native. Creative sampling remains a separate generation choice.\n\nA deployment that requires pure deterministic bfloat, block-scaled, microscaled or conventional floating execution can use Core on Kera and remove the seed. These are different declared contracts for the selected cell, not interchangeable marketing names for every repeated answer.","product-core.b85d6069ef":"PURE NATIVE","product-core.b0a7b16645":"SEEDED FLOAT","product-core.f6d05766e4":"PURE ON KERA","product-core.d799294b1e":"Three execution contracts","product-core.fc432e1a5b":"the selected path states which applies","product-core.4d34cd2025":"Binary, integer, Q, adaptive and exact paths. No seed.","product-core.341d953e69":"pure","product-core.7b1e96ec4c":"Floating, bfloat, block-scaled and microscaled replay.","product-core.c0ac484241":"seeded","product-core.a0cb0c8c3e":"Supported floating-family paths, no seed required.","product-core.8151325dcd":"pure-float","product-core.d3fecc3707":"creative sampling is separate","product-core.68112ac8dd":"never inherited by accident","product-core.0e058b0736":"When behaviour changes, one system should still own the explanation.","product-core.6e190fd575":"One accountable system","product-core.99a07c1bc1":"No chain of vendors","product-core.ceff9ee1f5":"pointing at the next layer","product-core.d43eebcf5f":"When a production result changes in a fragmented stack, responsibility is distributed. The framework blames the exporter. The exporter blames the runtime. The runtime blames the kernel. The kernel blames the driver. The driver blames the hardware. Core brings those responsibilities inside one system.","product-core.167e4e83b5":"The model definition, numerical choices, selected backend, dispatch path, determinism mode, and resulting execution record can be examined together. That does not mean every external dependency disappears. Data sources, applications, operating systems, and hardware still exist.\n\nIt means the AI machine itself has one accountable boundary. A review can ask which implementation ran, on which supported target and under which replay contract, without stitching the answer together from several vendors’ internal systems.","product-core.87053d7dda":"ONE DOSSIER","product-core.816d71406a":"ONE BOUNDARY","product-core.8643aa2cd1":"NO BLAME CHAIN","product-core.e02b627fa1":"The execution dossier","product-core.8d83a9d118":"examined together, not across vendors","product-core.68c2cc7f0c":"Model","product-core.014f0abf1b":"The definition and its numerical choices.","product-core.a1d03bb339":"Numeric contract","product-core.40b32720da":"Representation, width, accumulator, mode.","product-core.3865332f3e":"Kernel and host","product-core.abe905fefa":"The selected path and the machine it ran on.","product-core.c0f85d6679":"Replay","product-core.47fd10def6":"The record that lets the run be examined again.","product-core.833cec92f5":"externalities still exist","product-core.aa0f5f9bd1":"the machine answers as one","product-core.9d9874500e":"Core keeps one AI machine, but it has two execution postures.","product-core.9e0bd0c046":"Core Native and Core on Kera","product-core.663109b877":"One machine,","product-core.9d85e595eb":"different depth beneath it","product-core.fa58bf046b":"CORE NATIVE","product-core.830303b35d":"CORE ON KERA","product-core.d58a424bc5":"LICENCE GATES","product-core.ee00175c08":"Two postures, compared","product-core.9c5763c539":"depth differs, Core does not","product-core.3336470652":"Core is the machine in both","product-core.ebb434bc3e":"Kera is the deepest foundation","product-core.6ef01fa1c5":"Either posture should let the deployment move without replacing the AI system.","product-core.bc254c7b68":"The hardware can change without replacing the AI system","product-core.782acf270e":"Hardware changes","product-core.1aeb592061":"the system stays","product-core.c953e81101":"Infrastructure decisions should not force a model rewrite. Core keeps the model, operator surface, numerical design, and execution contract inside the same system while the deployment posture changes. The selected backend may differ. The organisation does not need to reconstruct the AI stack around it.","product-core.a573487e5a":"A licensed team may operate Core on organisation-controlled clusters or workstations. A regulated programme may require a fully isolated estate. A product may move part of its inference to the edge, while a browser application may need a local execution target.\n\nCore keeps those licensed operating postures inside one machine without claiming that every backend supports every cell. Core is not a managed-service product. The licence describes an operating posture and its supported scope, not a claim to every possible target or workload.","product-core.eb021533f0":"SAME MODEL","product-core.2316edbfbb":"SAME CONTRACT","product-core.a142214a05":"DIFFERENT POSTURE","product-core.52fa3a4811":"Four postures, one machine","product-core.be36bd50a5":"the backend moves, Core does not","product-core.89ecc6294c":"Private cluster","product-core.3cde14c0a6":"Licensed on organisation-controlled infrastructure.","product-core.5bb09e521d":"Your servers","product-core.2629c119a0":"On systems the organisation controls.","product-core.ad88b6e319":"Edge and browser","product-core.9baeb4d98a":"Local execution where the product lives.","product-core.64a176e362":"Isolated","product-core.d1646580eb":"No external dependencies permitted, still Core.","product-core.4b75d4c2d8":"unsupported cells are outlined","product-core.b7538b8454":"never quietly filled","product-core.de97fed5b0":"For European organisations, control over the machine is part of control over the AI.","product-core.12f9b5a961":"Built for European control","product-core.f4f6064789":"Sovereignty begins","product-core.fe9ab7ca62":"below the application","product-core.78ba7bc051":"Core is designed and built in the Netherlands. It is licensed for direct operation on systems controlled by the customer, at supported local and edge targets, or in isolated environments where external dependencies are not permitted. It is not included with managed Fabric. European origin does not create compliance by itself; it creates control over the machine that performs the work.","product-core.92d14d571c":"The purpose is not to place a European label on a foreign technical foundation. The purpose is to give European organisations control over the actual machine that builds and runs their AI: the framework, the training engine, the inference system, the numerical model, the hardware paths, and the operational record.\n\nEuropean origin does not automatically create compliance. It creates control. That control lets an organisation inspect the boundary that performs its supported work and decide where the machine operates. Compliance still depends on the organisation’s own rules, evidence and deployment choices.","product-core.49c99728a8":"BUILT IN NL","product-core.12c83b8493":"OPERATOR CONTROL","product-core.d8e367f9e1":"ISOLATED","product-core.5f7d6a39e9":"What control covers","product-core.efbe302f5c":"the layers below the application","product-core.a59ba24d63":"NL","product-core.b284f94827":"origin","product-core.370388aad7":"Designed and built in the Netherlands","product-core.c82d1b09cf":"EU","product-core.aa520898d5":"data path","product-core.1828ba692d":"Licensed customer-controlled operation","product-core.922cce49ed":"yours","product-core.96973e261b":"keys and systems","product-core.367762b82f":"Customer-controlled postures supported","product-core.458a3e3d45":"air-gap","product-core.4ee64af0b2":"isolation","product-core.834be89ee5":"No external dependencies where required","product-core.87f0fa38f4":"not a label on a foreign base","product-core.545cae588f":"control over the machine itself","product-core.d93e245c82":"Every Dweve product inherits the same machine.","product-core.7c8547722e":"Core in the Dweve stack","product-core.2964fea65d":"Eight products, one machine","product-core.b9056779b2":"nothing rebuilt","product-core.7ae5ddaa6b":"ONE MACHINE","product-core.fafd79ebb3":"EIGHT PRODUCTS","product-core.f4a1774adc":"NOTHING REBUILT","product-core.193800376f":"What each product inherits","product-core.58f2d59aa9":"the same machine, different jobs","product-core.1b37f71b67":"Cognition across 528 domain specialists.","product-core.aef2a2ef5e":"The specialists inside executable organisations.","product-core.14b725b1a1":"Spindle and Mesh","product-core.1733854a1e":"The knowledge pipeline and distributed workloads.","product-core.0a0e4949b1":"Aura and Fabric","product-core.a449dc8fe5":"Local development work and the human surface.","product-core.df36bbade5":"different problems above","product-core.b3207579ca":"one machine below","product-core.0637dc7369":"Bring the constraint that breaks your current stack, and watch it stay one system.","product-core.c4b3b20c7f":"Bring the constraint that breaks your current stack.","product-core.c4c9acb42d":"A new datatype. A lower numerical width. A different packing model. A CPU-only deployment. A browser target. A deterministic contract. A regulated environment. A different processor. See whether your existing AI system remains one system when the constraint changes. Then run the same requirement through Core.","product-core.4c85bc2993":"Evaluate Core against one real constraint","product-core.9e3c1d591d":"What the claims stand on","product-core.8b231d67d7":"2,900+","product-core.e8c39c4d7e":"operations","product-core.116c1095ec":"Across 76 categories, in one system","product-core.a17824536b":"~408K","product-core.868c9523ee":"implementations","product-core.76273264c4":"Hand-tuned execution cells, not one generic path","product-core.da4b9237ba":"2","product-core.28f47265fc":"execution postures","product-core.2eb2f8242d":"Core Native broadly, Core on Kera in strategic licences","product-core.77de68daec":"3","product-core.10a9d7555a":"determinism contracts","product-core.cbfa97fe51":"Pure Native, seeded Native floating families, pure Kera floating families","product-core.0787af82cd":"1-2 bit","product-core.7dcc900b33":"Packed bits, real computation","product-core.5c4821749c":"minimal","product-core.5f25a201a6":"4-8 bit","product-core.98d60989c8":"Low-bit integer","product-core.24a55decda":"Correct accumulators and overflow","product-core.36a883e762":"low","product-core.2334c28032":"Q-formats","product-core.509346fc49":"Exact fractional arithmetic","product-core.c072e8329e":"bounded","product-core.12add5938f":"FP8-FP64","product-core.0c47a1b436":"Conventional float","product-core.cd1e36d2b9":"FP8, FP16, BF16, TF32, FP32, FP64","product-core.f410e0466a":"standard","product-core.b55e22fe78":"exact","product-core.b43e93eb9d":"Exact paths","product-core.1c625c5900":"Where reproducibility demands it","product-core.02ab610f42":"reference","product-core.b14e0fee60":"Core Native","product-core.274a416211":"broad licence","product-core.2e4e834ecc":"Rust-native runtime","product-core.bbd4070f99":"hand-tuned kernels","product-core.22f5348aea":"backend dispatcher","product-core.8e0abfd232":"training + inference engine","product-core.7a6d8f2641":"deterministic paths, as supported","product-core.d6718674b4":"the broad Core product","product-core.5bd7bdd9b6":"Core on Kera","product-core.1d4b9c0d17":"strategic licences","product-core.a30386a485":"graph-native IR","product-core.5ec80e4334":"content addressing","product-core.9245d31354":"advanced lowering + fusion","product-core.99240f13d4":"ownership + effect semantics","product-core.914b009acc":"heterogeneous execution","product-core.a3f0d9a341":"the deepest execution foundation","product-core.d7ffadc6e2":"The execution matrix","product-core.93f7295555":"is the product.","product-core.5e14d21dc5":"Dweve Core is a complete AI compute stack for training and inference, understood through implementations, not framework labels. Its public registry spans more than 2,900 operations, 76 categories and 25 numerical families. Every supported execution cell is real code with named packing, backend and replay contracts.","product-core.04f9a2bc06":"Open the vocabulary","product-core.e9d3dc49d6":"The dispatch story","product-core.55479a4c12":"The public census","product-core.6539cdc3d5":"IMPLEMENTED","product-core.6ccb60071b":"Categories","product-core.d54ad009d1":"76","product-core.c6fd9237fe":"Numerical formats","product-core.f6e1126ced":"25","product-core.7b52009b64":"12","product-core.6dd272bb20":"Per supported cell","product-core.9200099244":"real code","product-core.f30168109a":"A complete computational vocabulary","product-core.a00e5c65c4":"From bit primitives","product-core.c70962763f":"to model architectures","product-core.1c8062f7b8":"Six tiers of vocabulary","product-core.11b1789d92":"base to architecture, one system","product-core.0f74d1a126":"Bit primitives","product-core.0dd8443dfe":"The lowest level, real packed-bit work.","product-core.47b96ecfec":"Arithmetic and vectors","product-core.9f76b8c72f":"Scalar, vector, reduction, transform.","product-core.07b11c9ed5":"Tensors and BLAS","product-core.288b40c312":"Matrix multiplication and tensor operations.","product-core.90acb3dec1":"Neural operations","product-core.500055fa9f":"Convolution, normalisation, activation, attention.","product-core.0a70fa78cb":"Training and inference","product-core.419ae58828":"Losses, optimisation, serving support.","product-core.590bdb486f":"Graphs and models","product-core.b25efcdada":"Composition up to complete architectures.","product-core.0ce01192ba":"one vocabulary","product-core.ac9bab5f9f":"one dispatch, one test system","product-core.2935a094e1":"A vocabulary is only complete if representations are real, not aliases.","product-core.ddb3608634":"Every representation is first-class","product-core.cea7cd83fd":"Binary is not a float tensor","product-core.609ae0792c":"waiting to be reconstructed","product-core.ea721b222b":"25 FAMILIES","product-core.1387cf3145":"SEMANTICS NAMED","product-core.7c0f597354":"NO FP32 FALLBACK","product-core.262633bd45":"The spectrum","product-core.9fb43461de":"packed binary through exact","product-core.52453a5ecb":"Explicit packed semantics","product-core.cecf76234f":"Int2-Int64","product-core.331d2320ff":"Integer widths","product-core.e7ad899b45":"Low-bit through full width","product-core.349d3a3eb8":"Q formats","product-core.48719f29e8":"No silent float inheritance","product-core.800006345c":"FP8, FP16, BF16, TF32, FP32, FP64","product-core.dfde7b582f":"Where the contract requires them","product-core.9304eb5c38":"no storage aliases","product-core.50493c5372":"semantics per format","product-core.a2919b0f0f":"Representation alone is insufficient. The accumulator is a separate contract.","product-core.73316ae5ac":"The value width does not","product-core.8987537eec":"silently define the maths","product-core.4ebc115cc9":"PER OPERATOR","product-core.60f38576e6":"WIDENING NAMED","product-core.ea4d93b3a5":"INSPECTABLE","product-core.0f37a74e15":"Two contracts, side by side","product-core.d4d3e56303":"storage and accumulation, separated","product-core.9e092dda4f":"Storage","product-core.27808eb5d7":"what the value carries","product-core.7afd33406a":"packed binary words","product-core.bd4e19d042":"Int4 blocks","product-core.304cab9491":"Q-format fixed-point","product-core.3c309d98fb":"FP16 half precision","product-core.d7bde8e6d9":"the representation on disk and in registers","product-core.c47d1e40dc":"Accumulator","product-core.1c2a53c9bd":"how results are summed","product-core.b13ec66246":"population counts","product-core.7284c3ae04":"Int32 accumulation","product-core.52b8fb8f1c":"wider fixed-point","product-core.2de52e6776":"higher-precision path","product-core.46ab56456c":"chosen by the operator, per cell","product-core.16884f51ef":"two decisions","product-core.e2a6e1571b":"never one silent default","product-core.0133803798":"Once the arithmetic is explicit, the memory representation must be just as explicit.","product-core.d62480f7ee":"Packing is part of the implementation","product-core.5a753a73ae":"Low-bit performance lives","product-core.e327b81afb":"in layout and movement","product-core.2a5a4357d5":"Low-bit performance depends on representation. Core treats packing as its own implementation dimension. The same logical operation may need different memory access, alignment, register use, and reduction strategy under each representation. Packed binary words, ternary encodings, bit planes and quantised blocks each change how a kernel must move data. A kernel is therefore tuned for the packing it actually receives.","product-core.3bfb803075":"Packed binary words, ternary encodings, bit planes, quantised blocks, scalar layouts, vector layouts, and backend-specific layouts each change how the kernel must move data. Core does not hide those differences behind a claim that one generic kernel supports everything.\n\nThe supported implementations are tuned for the packing they actually receive. Packing is therefore part of the named execution cell and its verification record, not a preprocessing detail that disappears once the model reaches a backend.","product-core.376fe016bf":"LAYOUT AWARE","product-core.74eec15d94":"ALIGNMENT","product-core.4fc9d67093":"NO GENERIC KERNEL","product-core.2b9971e698":"The packing dimension","product-core.e390194381":"what each layout changes","product-core.560f6d81ae":"Packed binary words","product-core.eb9794294f":"Bit instructions, dense movement.","product-core.9e108daaaf":"Ternary and bit planes","product-core.79c33d2ece":"Their own encodings, their own access patterns.","product-core.83f447ad2f":"Quantised blocks","product-core.bfa5700c83":"Block-wise scales and alignment.","product-core.b12cad384a":"Scalar and vector layouts","product-core.303f86c461":"Register use and reduction strategy shift.","product-core.93950269b6":"one logical tensor","product-core.203423cdfd":"many physical truths","product-core.4444333e04":"The kernel is therefore selected for the real cell, not only the operation name.","product-core.7d6ef27658":"The kernel matches the cell","product-core.144e385332":"Different execution cells","product-core.24d7c474cd":"are different problems","product-core.6cadc201c6":"ISA-SHAPED","product-core.a046cdf6de":"WARP-AWARE","product-core.c4e9281dd2":"The target families","product-core.a138b7f923":"each kernel written for its machine","product-core.10d5e48d4d":"x86 SIMD","product-core.2c32104010":"AVX2 around 256-bit vectors, AVX-512 with VPOPCNTDQ.","product-core.414768af9d":"wide","product-core.bb5a454c7c":"ARM NEON","product-core.77b741a1ea":"Native bit-count and vector paths.","product-core.d6267c98ba":"GPU ecosystems","product-core.38f7030850":"CUDA warps, ROCm wavefronts, Metal compute.","product-core.1a92520138":"parallel","product-core.c0b98e1948":"Browser and portable","product-core.6d48e34ca8":"Vulkan, WebGPU, and WASM constraints respected.","product-core.bc109fb076":"portable","product-core.716727cc21":"one abstract operator","product-core.6501a3a262":"kernels shaped per target","product-core.3e94fd9d03":"A target label is not enough. Support must be honest at the feature level.","product-core.2fa7ee2b6f":"A slice of the execution registry","product-core.6729e00dc5":"A visible sample","product-core.8370220cbe":"of a much larger machine","product-core.3fc48d18de":"The board below shows a small set of representative intersections between operation families and execution targets. Every combination shown is implemented. It does not define the edge of Core's coverage, and a combination omitted from the visual is not being labelled unsupported.","product-core.3ba5bc65b4":"The actual implementation registry spans more than 2,900 operations, 76 operation categories, 25 registered numerical format families and nine execution dimensions. A complete cell also records datatype, width, packing, accumulator, backend, instruction set, dispatch policy and determinism mode.\n\nThis visual fixes most of those dimensions to remain readable. The small matrix is an inspection surface, not a claim that each operation has one generic implementation or that a format label alone defines the arithmetic.","product-core.72f25645ec":"SELECTED CELLS","product-core.e77aac31c1":"2,900+ OPS","product-core.79e57a2b05":"OWNED REGISTRY","product-core.eb8b5f64d6":"What a complete cell carries","product-core.78a5e44ef4":"the dimensions compressed by the visual","product-core.2cdc47fbe3":"Operation contract","product-core.9ccef39957":"The algorithm and the result it must produce.","product-core.7c7795de3b":"Representation contract","product-core.586d8bafac":"Datatype, width, packing and accumulator remain explicit.","product-core.0a50f145a8":"Execution path","product-core.043389aa9d":"Backend, instruction set and dispatch choice are named.","product-core.c7b45f55ed":"Verification record","product-core.c5c7bc9224":"Replay, tolerance and target checks remain attached.","product-core.ea278c1d43":"selected intersections","product-core.d65c2359b4":"not a coverage boundary","product-core.d46a7d4e20":"Select any shown cell to inspect one implemented path.","product-core.eca36276d6":"You have profiled this before","product-core.b4d843c30e":"The framework says","product-core.banner.engineering.headlineAccent":"it supports the target.","product-core.51efd7d4be":"A broad target label does not state whether the declared representation, packing, and target-specific execution path were retained.","product-core.757ac6871b":"A browser deployment can be a separate model export. If the executed kernel is not recorded, the path cannot be independently examined.","product-core.3c4a0639b1":"Around one supported target","product-core.6668ed36d5":"The declared representation is not stated","product-core.da4e3b4185":"The packing contract is not stated","product-core.f6f9426202":"The target-specific execution path is not stated","product-core.55e154f848":"The executed kernel cannot be examined","product-core.0a4d649b90":"That is compatibility. It is not coverage.","product-core.56ea444365":"Runtime dispatch is per operation","product-core.1da447932b":"A machine is not","product-core.04d5ca38df":"one backend","product-core.93053627e4":"HOST-AWARE","product-core.75cc13e4b6":"RECORDED","product-core.2c8adcc421":"One dispatch decision","product-core.1023f69aa1":"from operation to named kernel","product-core.ddfe163345":"01","product-core.5ed35d2c0b":"Operation arrives","product-core.dd66fd37e8":"With datatype, packing, shape, policy.","product-core.824f601c2a":"op","product-core.bcac9d1d8e":"02","product-core.13aaf08159":"Cell is resolved","product-core.fad16e194a":"The nine axes name one execution cell.","product-core.5f435eb302":"cell","product-core.3ea6c91e24":"03","product-core.acc2240921":"Kernel is selected","product-core.8beb3ae937":"The implemented path for this host.","product-core.ece2b194b4":"kern","product-core.798f861ee7":"04","product-core.f248b8682e":"Ledger entry written","product-core.519e297731":"The selected path, recorded and verifiable.","product-core.7babc233de":"log","product-core.09cef94930":"one process, several backends, one ledger","product-core.d42afedf28":"no single-device declaration","product-core.73f0cbb58c":"a decision per operation","product-core.af8dd07e70":"Every optimised path needs a stable floor beneath it.","product-core.8e6238bb36":"The scalar path is part of the architecture","product-core.b1bc02741f":"Universal availability","product-core.10f682916b":"and a correctness anchor","product-core.c2cc12d7e3":"UNIVERSAL FLOOR","product-core.bbf9ae7607":"REFERENCE","product-core.f899071b36":"PROOF PATH","product-core.5da23df25a":"The calibration loop","product-core.7e0eb1625a":"how optimised paths earn trust","product-core.db1c784524":"Reference","product-core.9bc6a39b83":"Scalar produces the trusted trace.","product-core.a085603f85":"Optimise","product-core.973175177c":"The target-specific kernel runs beside it.","product-core.8d105cf44d":"Compare","product-core.c3e24d7a51":"Results checked according to the contract.","product-core.bb54db510a":"Accept","product-core.2e54541bbb":"The optimised path earns its place.","product-core.67e4036d7e":"fast is not the definition of correct","product-core.4624805885":"scalar holds the definition","product-core.57525c9f36":"The machine is larger than the kernels. It carries the model through its whole lifecycle.","product-core.60eedbad4e":"One framework, trainer, engine, and dispatcher","product-core.4a13466a53":"One machine through","product-core.6cdccd11cb":"the model lifecycle","product-core.c1de9a7aa1":"Core is not a kernel collection surrounded by external infrastructure. The same operation system is used to define models, train them, optimise them, execute them, serve them, and verify their behaviour. The model does not need to leave Core merely because its lifecycle moved from research to production.","product-core.3e45d30f41":"The framework provides model authoring and composition. The trainer includes quantisation-aware training, distillation, progressive precision, distributed training, AdamW, RMSProp and quantised optimiser variants. The inference engine carries pure deterministic and seeded replay contracts plus a separate creative sampling policy.\n\nThe dispatcher resolves the implementation and execution foundation per cell, then records what ran. These surfaces share one live representation, so their connection is not an opaque export boundary between separate internal products.","product-core.4e377f797c":"ONE VOCABULARY","product-core.815b73af1c":"END TO END","product-core.f87ec2f949":"Four surfaces, one contract","product-core.d2fc0dccba":"each reads the same operator system","product-core.fb27c5cf22":"Model authoring and composition.","product-core.9c51283831":"QAT, distillation, progressive precision, distributed.","product-core.396f1ac82c":"Three modes, backend selection, serving, replay.","product-core.48e0562d54":"The runtime decision, recorded per operation.","product-core.adc54acff2":"no serialising between stages","product-core.64821a4d86":"one live representation","product-core.f2ec2c17e7":"Low-bit models therefore begin as low-bit models, not as compressed exports.","product-core.a8932c3645":"Binary is not an export format","product-core.a3db19f6e4":"The target representation","product-core.3fedbe9a61":"participates in learning","product-core.40f3603e9c":"QAT","product-core.d4e94df55b":"DISTILLATION","product-core.0bedb8a1ad":"ADAPTED OPTIMISERS","product-core.344034983d":"Three routes down","product-core.37f230b788":"all ending in the target representation","product-core.b4149804a6":"Quantisation-aware","product-core.22fe1e1bdb":"The low-bit representation trains from step one.","product-core.f20449e3f7":"Distillation","product-core.80eedd5642":"A full-precision teacher supervises the student.","product-core.dfb35360ec":"The model descends through numerical stages.","product-core.f27e39932d":"Adapted optimisation","product-core.d6c6656a51":"AdamW, RMSProp, and quantised variants.","product-core.e5702897a6":"trained for its representation","product-core.8389b88c57":"not compressed after the fact","product-core.5a96d4f4d3":"Once trained, the same model can request different variance contracts.","product-core.f14760bd3f":"One dispatcher, three determinism contracts","product-core.d7985fc894":"Pure internal replay,","product-core.d19e0f66b2":"or pure through the foundation","product-core.9faa9bf934":"Core does not flatten every numerical path into one determinism claim. The execution cell and foundation determine the contract. The model and operation remain the same. What changes is whether the selected numerical family can be replayed from complete state alone or requires a pinned seed under Core Native.","product-core.a5d0a3c4f4":"Covered binary, ternary, signed and unsigned integer, fixed-point, adaptive and exact cells are pure deterministic in Core Native: no seed, no stochastic replay mechanism and bit-identical output from the same complete state. Native floating, bfloat, block-scaled and microscaled cells use seeded replay, with graph, implementation, packing, scales, backend, device contract, execution order and seed pinned.\n\nCore on Kera makes supported paths in those floating families pure deterministic too by fixing graph identity, canonical ordering, reduction topology, effects, lowering and memory ownership. The selected policy is recorded with the cell, so a test can verify the contract actually declared for that path.","product-core.fb575f44f0":"Three contracts","product-core.76e287a36a":"the same model serves all of them","product-core.d831a0e14c":"Binary, ternary, integer, fixed-point, adaptive and exact. No seed.","product-core.ac7c881c64":"Floating, bfloat, block-scaled and microscaled, with the complete seed record.","product-core.92713d4709":"seeded","product-core.850c7ea234":"Supported floating-family paths, without a seed.","product-core.29ba2dab6b":"sampling policy is separate","product-core.ac3b59db95":"the arithmetic contract stays explicit","product-core.278366a724":"The API language should not fork the machine underneath.","product-core.3292abb6b7":"Rust and Python are two surfaces, not two systems","product-core.832b8697b5":"The language","product-core.03a0085aed":"is a front door","product-core.d59ed14bf9":"RUST","product-core.8b21c0e40c":"PYTHON","product-core.72b45a09f6":"Two front doors","product-core.a2f4a1f01b":"the same Core semantics behind both","product-core.3ef496fd6e":"production surface","product-core.84d843ecdf":"static types + control","product-core.ea89d6a305":"standalone binaries","product-core.bb89a0795f":"thread + memory control","product-core.c64d4fae02":"no runtime in production","product-core.3e7adf1026":"direct, native integration","product-core.46a691d4ce":"research surface","product-core.63dfeccbb8":"rapid iteration","product-core.1507a0ad26":"ecosystem integration","product-core.e80903c106":"array interchange","product-core.075fcdc41c":"model import + export","product-core.927fbb44b4":"familiar research workflows","product-core.7f5aea64c5":"two surfaces","product-core.3aa5db6df5":"one execution architecture","product-core.b568a3c62f":"Beneath those surfaces, Core has two explicit execution postures.","product-core.faa37b572e":"The broadly available","product-core.44a05aecb0":"Rust-native execution system","product-core.facd16e9b0":"Core Native is the Rust-native execution foundation available across the broad product. Its framework, trainer, inference engine, numerical registry, packing system, kernel library and dispatcher execute directly without requiring the customer to licence Kera. It is Core's own runtime, not a wrapper around another machine-learning framework or accelerator runtime.","product-core.db15116fcc":"Its covered unipolar, bipolar, ternary, signed and unsigned integer, Q-format, generic fixed-point, adaptive and exact cells are pure deterministic without a seed. Its floating, bfloat, block-scaled and microscaled cells use seeded replay with their scales, layouts and complete execution record pinned.\n\nCore Native remains the complete AI machine when Kera is absent. The record makes the selected contract testable on the declared path rather than applying one undifferentiated determinism claim to the entire numerical estate.","product-core.bfe9123cb1":"RUST NATIVE","product-core.9246fd03de":"PURE NON-FLOAT","product-core.790636901c":"SEEDED FLOAT","product-core.1ea35e1910":"Inside the chassis","product-core.32a617d98b":"what Core Native ships","product-core.c8d276b2b8":"Framework and engines","product-core.81df93109f":"Authoring, training, inference, in one system.","product-core.ca8d4830bb":"Numerical and packing estate","product-core.9ecf3d204d":"Binary polarity, Q, adaptive, bfloat, blocks and layouts.","product-core.d5617d27c9":"Kernels and dispatcher","product-core.53e2381ec8":"Hand-tuned cells and host-aware selection.","product-core.b4f8831cb9":"Determinism matrix","product-core.f6c2d3fa04":"Pure non-floating cells; seeded floating-family replay.","product-core.3b1fbb0cc2":"Core's own runtime","product-core.69473491f8":"Kera is optional depth","product-core.6273462b6c":"Selected strategic agreements can place a deeper execution system beneath the same Core machine.","product-core.6bb7402276":"The deeper foundation","product-core.80acd089c0":"makes floating families pure too","product-core.abbfef9cf3":"GRAPH-NATIVE IR","product-core.77ecc5595d":"PURE FLOATING ESTATE","product-core.e660334f13":"NO SEED","product-core.f6707d80a3":"The deterministic lowering path","product-core.a4a22ff0a3":"what the optional foundation fixes","product-core.5ac1a6c71e":"Content-addressed graph","product-core.e5d7457ada":"The computation identity is fixed.","product-core.85c579f022":"Canonical schedule","product-core.aac315caf0":"Operations, blocks and reductions have one order.","product-core.285abb5f03":"Effects and ownership","product-core.ddb92a77a9":"Memory movement, scales and side effects are explicit.","product-core.881f970c0f":"Deterministic lowering","product-core.9f95789a1e":"Supported floating-family paths require no seed.","product-core.20f383606a":"Core supplies the operation universe","product-core.fb7a52ff0f":"Kera supplies deterministic depth","product-core.329d9c35c4":"Model interchange remains useful, but it should be an explicit edge.","product-core.3aa3d81de4":"Imports and exports are boundaries","product-core.2543ca71d2":"Interchange is not","product-core.26f6a1a9df":"internal glue","product-core.ffc871b86e":"Core supports model interchange because migration and coexistence are real requirements. Existing models can enter. Core models can leave where another runtime is required. An imported model becomes a Core model. An export is a deliberate boundary crossing, not an internal step Core takes to talk to itself.","product-core.c4c9695da7":"But interchange is not used internally to connect Core's own framework, training engine, inference system, and backend implementations. The model does not repeatedly serialise itself merely to cross artificial product boundaries inside the same platform.\n\nAn import or export can be important at the edge, where another system genuinely begins or ends. It is not a substitute for internal continuity across authoring, training, inference, dispatch and replay inside the Core machine.","product-core.a5e6d8940b":"IMPORT DOOR","product-core.116693ff06":"EXPORT DOOR","product-core.6f9701bf1f":"SEALED INSIDE","product-core.0b18be066f":"Boundary or glue","product-core.bae98f99c5":"the difference stated plainly","product-core.f335d04d31":"Migration boundary","product-core.4eb88f04f3":"A door at the edge, crossed deliberately.","product-core.856eb9f08a":"Coexistence","product-core.9bb2804a67":"Other runtimes exist; the doors serve them.","product-core.bc45ab8c04":"Internal glue","product-core.f707aed1c0":"Refused: no serialising between Core's own stages.","product-core.7e5a975b6a":"Identity","product-core.ac381e3c61":"Inside Core the model stays one live representation.","product-core.ff884436f5":"doors at the edge","product-core.8d77aa0def":"never corridors inside","product-core.a97c0a08a2":"The final test is whether the claim survives on the customer's own hardware.","product-core.4480b0732c":"Verification runs on the machine that matters","product-core.071a7aa6fa":"Name the cell, kernel,","product-core.1821acab14":"path, and replay result","product-core.8f3d26e43d":"YOUR HOST","product-core.e090842711":"NAMED PATHS","product-core.4b2efa8180":"RUNNABLE TESTS","product-core.49ca856d10":"The verification ladder","product-core.1ca57c1958":"run it where it will run","product-core.d338d3edac":"Census","product-core.3d5e655037":"Coverage tests confirm categories and formats.","product-core.840e1b364a":"Dispatch","product-core.43e038fe29":"The expected implementation was chosen.","product-core.44be779a71":"Scalar reference against the optimised path.","product-core.b7e5032a0f":"Identity or declared fixed-point tolerance.","product-core.d40b74eb53":"no invented numbers","product-core.b47b54e8c7":"runnable commands, named hardware","product-core.7fa5dd20f2":"Bring one unsupported combination, and see where Core begins.","product-core.aee4dbe6da":"Bring one unsupported combination.","product-core.4c8964550f":"An unusual datatype. A packed representation. A mixed accumulator. A CPU instruction set. A browser target. A low-bit training method. A pure internal replay requirement. A model that must move between several of them. That is where partial systems stop. That is where Core begins.","product-core.ae7f57129d":"Run the Core benchmarks","product-core.f37e89299c":"What the engineering stands on","product-core.9977e43b09":"operation census","product-core.f0d55f6599":"76 categories, 25 registered numerical format families, verifiable by test","product-core.0ade7c2cf9":"9","product-core.4bb62af4b0":"axis execution cell","product-core.ce2bc284d9":"Storage, accumulator, packing, and dispatch as contract","product-core.356a192b79":"1","product-core.002f35df66":"named path per run","product-core.185cca0402":"Selected kernel and backend, recorded in the trace","product-core.5b8e33382f":"We built the whole machine","product-core.e1f0dd6ba2":"underneath AI","product-core.a83f3f4da9":"Most AI products are only the part you see. Behind the screen, the work passes through frameworks, runtimes and processors owned by several companies. Core is Dweve’s own AI compute stack underneath its products: training and inference in one machine, choosing the numerical method and the hardware that fit the task.","product-core.8373c2c863":"See what sits underneath","product-core.de8b85da07":"Meet the products","product-core.0b2648b110":"Behind one answer","product-core.e1486a3eab":"The app you see","product-core.89eb40cecd":"one screen","product-core.4da4a2d05c":"The machine below","product-core.5ca08c0d7f":"built by Dweve","product-core.20a72bcb05":"Outside companies in the chain","product-core.c641059b18":"not required","product-core.daedfdd24e":"Where the work runs","product-core.98371c6608":"decided by the task","product-core.194ea85f96":"What you manage","product-core.0feca720e2":"nothing","product-core.3e784ffc5d":"One machine underneath everything","product-core.83e01d9264":"The products feel different","product-core.b07e85c3fd":"The machine is the same","product-core.9d7d487fb6":"NO INSTALL","product-core.541a5acda1":"NO NEW SKILLS","product-core.ae5629500c":"UNDERNEATH","product-core.c8a7c5eb23":"Who uses the machine","product-core.406dbfd5aa":"every product, every day","product-core.6122e436be":"When it thinks through a problem.","product-core.cff7feb3f6":"When a team of specialists works on your task.","product-core.ec2c1e0c7b":"When it processes and protects knowledge.","product-core.70d4df8873":"When you ask, upload, and run workflows.","product-core.84d82c00e9":"different jobs above","product-core.f9791c03ad":"And that machine carries more than one kind of tool.","product-core.de00531879":"The right tool for each calculation","product-core.3bda3b007b":"A workshop with","product-core.c8cdd42d2d":"more than one tool","product-core.2b27b1d0dc":"Imagine a workshop with only one tool. A tiny screw, a wooden shelf, a steel beam, the same tool for all of them. That is how much of today's AI infrastructure works: the same heavy kind of calculation for almost everything, even when the job could be done in a simpler way.","product-core.a2dd868b83":"Core contains many different ways to perform the work. It can use very small, efficient representations where they are enough. It can use larger and more precise calculations where the task needs them.\n\nIt can choose a different path for a different kind of operation. Rust and Python are implementation languages that give direct access to the same machine; everyday work does not require learning either one. The complete workshop is already inside the machine.","product-core.e6c364db5a":"SMALL ENOUGH","product-core.a73cd3a0e1":"PRECISE","product-core.1014f31420":"FULL WORKSHOP","product-core.c046647874":"Three ways to work","product-core.f2f9a942b5":"chosen per job, not per vendor","product-core.c86f7dbe3f":"Small and efficient","product-core.6e2231501f":"Where a light representation is enough.","product-core.dfccc06f14":"light","product-core.cfe23d3428":"Larger and precise","product-core.87309f21bf":"Where the task needs the accuracy.","product-core.d53a4c6252":"precise","product-core.33ca88584b":"A different path","product-core.5e5f23a987":"A different kind of operation gets its own way.","product-core.80c656bf28":"fitted","product-core.64fd8bf202":"no single hammer","product-core.d7982b9acf":"the job picks the tool","product-core.7f885c3d18":"Which is why the computer underneath does not have to be special.","product-core.2db4555b88":"The computer does not have to be special","product-core.9b5a01ce2a":"Chosen for the work,","product-core.13de4c1cd8":"not for the vendor","product-core.04622db189":"Many AI systems begin with the assumption that an expensive graphics processor is required. Core does not. It includes paths designed for ordinary processors as well as accelerators. Supported Dweve workloads can run on modern laptops, office computers, servers and edge devices without a dedicated AI graphics card as the minimum requirement. Accelerators help when they are present, but they are not the entry price.","product-core.d1700154f1":"That means supported Dweve workloads can run on modern laptops, office computers, servers, edge devices, and other machines without making a dedicated AI graphics card the minimum requirement. Larger jobs may still use more powerful hardware.\n\nThe difference is that the whole system was not designed around one expensive processor from the beginning. The computer is chosen for the work. The work is not forced to follow one computer vendor.","product-core.6a06444a7e":"ORDINARY CPUS","product-core.c4cc3a463c":"ACCELERATORS","product-core.bac6375073":"NO GPU MINIMUM","product-core.8126418164":"Where supported work can run","product-core.4c3c251f3b":"no dedicated AI card required","product-core.77751f77c2":"Modern laptops","product-core.0f83ed1fbd":"The machine already in front of you.","product-core.410440e985":"Office computers","product-core.9c0212e2e4":"The hardware the organisation already owns.","product-core.acca64b835":"Servers","product-core.5ea789db0f":"Larger jobs on stronger machines, when needed.","product-core.0b8cdda4e5":"Edge devices","product-core.142650550c":"Close to where the work actually happens.","product-core.cc6abfe45e":"the computer serves the task","product-core.4badc9c349":"never the other way round","product-core.feb64f551e":"And when ordinary machines can do the work, the work can stay near you.","product-core.ef089ed0de":"More work can stay close to you","product-core.c16d631955":"AI closer to home:","product-core.2582e54c0c":"faster and more efficient","product-core.8c8627eb47":"LOCAL","product-core.aafa8372bd":"NEARBY","product-core.fccf9dd21f":"RULES HOLD","product-core.60975ee63b":"What this means day to day","product-core.b51b392e59":"four everyday situations","product-core.66480519f3":"Your photos and files","product-core.d5f20211e4":"They can stay on your own device for supported tasks.","product-core.0edf776e89":"Your workplace","product-core.e557e0f94a":"Work documents stay inside your employer's own systems.","product-core.bc3210e860":"Your hospital and council","product-core.ba9bf4aa6b":"Services that hold your records keep their own rules.","product-core.a99a86b0db":"On the road","product-core.ec18a33d45":"Features keep working without a constant connection.","product-core.739f0e772a":"distance is a choice","product-core.5558b3bdde":"not a requirement","product-core.0d96cee8e3":"Sometimes the connection drops. The machine can already be there.","product-core.8d6b4be87c":"You have used this app","product-core.27a7bb98b0":"The app felt","product-core.banner.consumer.headlineAccent":"local.","product-core.762d55043f":"The model belonged to one company, the software that ran it to another, and the processors to a third.","product-core.49d3eb221b":"The answer crossed a continent twice. And when one link in the chain failed, the friendly screen stopped being intelligent.","product-core.8203b0bda5":"Behind one friendly screen","product-core.b27f11f57b":"The model, owned elsewhere","product-core.a5103ae278":"The runtime, owned elsewhere","product-core.c0cc3f403b":"The processors, owned elsewhere","product-core.5a07a5b5ac":"The answer, travelling continents","product-core.4750d0f4d0":"You used a screen. The machine lived somewhere else.","product-core.5a6251bbfc":"Core, the machine underneath","product-core.541a822780":"It can keep working when the connection does not","product-core.4461e4f802":"The intelligence can be","product-core.43d3060bfb":"brought to the device","product-core.8948780ffa":"Some Dweve features can operate locally because the machine they need is already present. When the feature and its required data are available on the device, Core does not need to contact a remote service merely to perform its calculations. Where the product supports it, an interrupted connection does not have to stop the work.","product-core.ee00dfb661":"Where the product supports it, Core makes offline and interrupted-connection use possible. A local or nearby path can use the available model, numerical method and processor, then state what ran.\n\nThe feature does not become intelligent only after it phones another company. If a task needs a service that is not present, the product can say so plainly instead of silently changing the contract.","product-core.2b9914386b":"OFFLINE","product-core.e556cdf3fe":"NO REMOTE CALL","product-core.b0d5961a04":"ON DEVICE","product-core.38a64d238c":"When the line drops","product-core.c5bcfe0590":"what changes, and what does not","product-core.dc4c07aa9c":"The feature","product-core.2775a8971b":"Keeps working where the product supports it.","product-core.268526d459":"Already on the device, goes nowhere.","product-core.9d175e50eb":"The calculations","product-core.892aae8ced":"Performed by the machine that is present.","product-core.aa3f1ddebc":"The waiting","product-core.c5a64e59b9":"None, because nothing has to travel.","product-core.1b838c88e6":"no remote call","product-core.f6b7a13395":"just to think","product-core.a1167cda75":"Running the right-sized machine also costs less.","product-core.7fc5f617e4":"It uses less than a one-size-fits-all engine","product-core.12771a6d4c":"Use the machine","product-core.e95623b339":"the work actually needs","product-core.98133ac1a9":"A machine that uses the heaviest calculation for every task needs more memory, more electricity, and more expensive hardware. Core can use smaller and lighter ways of representing work where those methods are appropriate. The principle stays the same: use the machine the work actually needs.","product-core.0120bf2e3b":"It can pack information efficiently. It can use the instructions already built into the processor. It can avoid moving more data than the operation requires. Together, those choices keep the operation efficient.\n\nThat helps Dweve build AI that is cheaper to operate without turning every user request into a large remote computing job. The work still follows a declared numerical representation and supported path; efficiency never hides a different contract.","product-core.adc64311fe":"LESS MEMORY","product-core.b989e8db9f":"LESS ELECTRICITY","product-core.c46ab6ffc8":"LESS HARDWARE","product-core.b1ddcd615c":"Where the lightness comes from","product-core.549d9b6968":"three habits of the machine","product-core.59522c0e93":"Pack it","product-core.8739d775ca":"Information stored efficiently, not lavishly.","product-core.dd3960a313":"Use what is there","product-core.3a5786a039":"The instructions already inside the processor.","product-core.3b56f2d58e":"Move less","product-core.1fb60ac35c":"No more data in motion than the operation requires.","product-core.865a2717af":"savings vary by task","product-core.57670f0fdd":"the principle never does","product-core.f879931e8e":"Lighter does not mean vaguer. The work stays visible.","product-core.932bf736a3":"The answer does not have to become a mystery","product-core.e16abb4dcd":"The visible work","product-core.27838e25c4":"around the answer","product-core.512c11b901":"Core can record the operation and execution path used for supported work. This is not a claim that you should read an AI model's private thoughts. It means the system can preserve the visible work around the answer instead of asking you to trust a sentence produced by a black box.","product-core.e55b933486":"That can help Dweve products show which model or method was used, which sources and inputs were involved, which rules or constraints affected the result, which hardware path performed the calculation, and which recorded decisions led to the outcome.\n\nIt does not ask people to inspect private model thoughts or read an engineering log for every answer. The product can preserve the visible work around an outcome instead of asking you to trust unexplained text. That record belongs to the supported work that ran; it is not invented afterwards.","product-core.da70f968a8":"PATH RECORDED","product-core.83cb4ff91e":"WORK SHOWN","product-core.97a179d466":"NO BLIND TRUST","product-core.518ab53f64":"What a product can show","product-core.54a14b3c4e":"around one answer","product-core.3a07195c8e":"The method","product-core.27b00959a7":"Which model or method was used.","product-core.bb7a289d4a":"The sources","product-core.b1e5db679a":"Which inputs were involved.","product-core.03b34e8afe":"The rules","product-core.38ff26776d":"Which constraints affected the result.","product-core.24a2112a54":"The hardware","product-core.0d86476ba7":"Which path performed the calculation.","product-core.79dd9d0997":"not private model thoughts","product-core.d835b5393f":"the work around the answer","product-core.b6ad89cfb8":"And when you ask the same thing twice, the behaviour is a choice.","product-core.c5afb5192b":"The same request should not change by accident","product-core.8f3d400015":"Pure when it can be,","product-core.be6fe8f4e9":"seeded for native floating","product-core.004d721580":"Core does not call every repeated answer deterministic in the same way. Compact binary, whole-number, fixed-point, adaptive and exact work can repeat exactly in Core Native without any seed. Native floating, bfloat and block-scaled work repeats from a recorded seed. With optional Kera, supported work in those floating families can repeat exactly too, without a seed.","product-core.0671147e29":"The product records which promise applied. A pure result depends on the complete state alone. A seeded result records the seed and execution path that reproduced it.\n\nA pure Kera floating result fixes the graph and calculation order so no seed is required. Creative writing or sampling remains a separate choice when variation is wanted.","product-core.ebf5bdeec0":"SEEDED FLOATING FAMILIES","product-core.9296242837":"PURE FLOATING ON KERA","product-core.ba9e305d4a":"Three kinds of repeatability","product-core.8e8b144946":"the product states which one it used","product-core.4c4dcfde17":"Binary, whole-number, fixed-point, adaptive and exact work.","product-core.9697fecaae":"exact","product-core.45705488b9":"Seeded Core Native","product-core.f24339c0e7":"Floating, bfloat and scale-owning floating work.","product-core.1e1f43877c":"seeded","product-core.47ed8fde8f":"Pure Core on Kera","product-core.e1fc0f3fab":"Supported floating-family work without a seed.","product-core.55ff4e5a5b":"creative variation is a separate choice","product-core.40624fafc3":"never by accident","product-core.56007a0897":"All of it built in a place whose rules you recognise.","product-core.41db2c81ba":"The machine behind the work,","product-core.c63ebc8e46":"built here as well","product-core.2f0c6265bb":"Core is designed and built by Dweve in the Netherlands. That matters because the machine underneath the product determines where data can run, which outside companies are required, and who can be held responsible when something fails. A Core licence covers direct operation on infrastructure the organisation controls.","product-core.120a550369":"Managed Fabric on the public Mesh does not include Core access or Core operation. A Core licence grants direct operation on infrastructure controlled by the organisation, including isolated environments. That distinction matters.\n\nManaged products can be useful without transferring the underlying machine. Licensed organisations can operate Core within their own stated boundary. The technology is built and governed in Europe; geography belongs to the operating model, not a marketing shortcut.","product-core.724def14aa":"LICENCE","product-core.f90e96536a":"ISOLATED","product-core.ea21f364bc":"Why the origin matters","product-core.1c5f1a9e4a":"the machine decides these things","product-core.9195a2c5fb":"built here","product-core.71a997251f":"hosted here","product-core.ed1a83ed1e":"Not included with managed Fabric","product-core.b8eec498eb":"your infrastructure","product-core.509aee8d53":"Organisations can run it themselves","product-core.5d2b90a4c4":"sealed","product-core.1b84995dfa":"isolated","product-core.48dc647a2f":"For programmes that require it","product-core.63ecf04883":"not only stored in Europe","product-core.6249b22be9":"performed in Europe","product-core.42efca658a":"And after all of that, you never have to think about any of it.","product-core.b325d6d9b7":"You never have to see the complexity","product-core.fb787a9719":"To you,","product-core.786a31413c":"the result is simple","product-core.9738bb98f3":"Core contains thousands of operations and many ways to run them. You do not have to select any of them. The Dweve product makes those decisions according to the task and the rules around it. You never choose a numerical format, a packing method or a backend. The app opens, the task runs, and the product can still state the path that actually ran. The choices you never see are the ones Core has already resolved.","product-core.40e4bd7011":"You do not choose the numerical format. You do not choose the packing method. You do not choose the processor instruction. You do not choose the backend. The app opens. The task runs. Your work stays where the product says it will stay.\n\nThe answer arrives. The machine underneath has done its job. When a supported task needs a different path, the product makes that choice under its declared rules and can state the path that actually ran.","product-core.385e36ad55":"NO SETTINGS","product-core.b5d2541ad8":"NO JARGON","product-core.bf319a9f35":"JUST THE ANSWER","product-core.d25ff2dcfd":"Choices you never make","product-core.ca9986b407":"the product makes them for you","product-core.9303abac72":"The numerical format","product-core.11900fc612":"Picked to fit the task.","product-core.f7852d53e6":"The packing method","product-core.f45d421575":"Handled inside the machine.","product-core.2c7e3f0b63":"The processor instruction","product-core.000865b5bc":"Matched to your hardware.","product-core.a42af79a0d":"The backend","product-core.91957341b5":"Selected by the product, per operation.","product-core.4502a42999":"the machine does the choosing","product-core.4676601630":"you do the asking","product-core.5cc127301f":"You use the product. Core quietly makes the whole system possible.","product-core.e4a3abce27":"The complete machine behind every Dweve product.","product-core.08961b9cbb":"Dweve did not build a thin app on top of somebody else's AI stack. It built Core. That is why Dweve can make different choices about hardware, privacy, efficiency, deployment, and control. You use the product. Core quietly makes the whole system possible.","product-core.8ed9b19f63":"Meet the products built on Core","product-core.6756088240":"An AI stack can appear complete while every important responsibility belongs somewhere else. The organisation may own the model file. It does not own everything the model requires in order to exist. The model framework relies on a numerical library. The numerical library relies on an accelerator runtime. The accelerator runtime relies on a hardware vendor. The quantisation pipeline relies on another tool.","product-core.3b97fe3ef1":"The inference server relies on an exported representation. The production deployment relies on all of them remaining compatible. A change in hardware can force a new runtime. A change in precision can force a new training path. A change in deployment can force a new serving system.\n\nA new regulatory requirement can expose gaps nobody designed the original stack to answer. The problem is not simply that there are too many products. The problem is that each one covers only part of the computational space.","product-core.eb655cb3a8":"An organisation should be able to change a technical constraint without losing the model. Core keeps those changes inside one machine. The representation may change. The packing may change. The accumulator may change. The selected kernel may change. The processor may change. The computational responsibility stays with Core. A binary operation on a CPU should still be the same operation when it is deployed through a different instruction set. An integer model should not require an unrelated inference system because it no longer resembles the framework’s preferred floating-point path. A browser deployment should not mean rebuilding the application around a new computational model.","product-core.b4762e4138":"A deterministic deployment should not require a second version of the model. Covered binary, ternary, integer, fixed-point, adaptive and exact cells can be pure deterministic in Core Native without a seed.\n\nCore keeps the model, representation and execution contract together while making the replay posture explicit. Native floating families use seeded replay, and supported floating work can use Core on Kera when pure deterministic identity is the required contract.","product-core.75240f8920":"Most AI infrastructure has a preferred numerical centre. Everything close to that centre works well; everything else becomes a plug-in, fallback or export. Core has no such centre. Unipolar and bipolar binary, native ternary, signed and unsigned integer, Q-format fixed-point, adaptive, bfloat, block-scaled, microscaled, conventional floating-point and exact paths are all real parts of the machine.","product-core.d309fc0008":"This is why Core can support radically different efficiency, accuracy, memory, and reproducibility requirements inside one framework. Not because every model must be low-bit. Because no model should be trapped in a format chosen by someone else's hardware strategy.\n\nA binary operation, a Q-format path and a conventional floating path each keep their own representation and execution contract. Core can choose among supported cells without pretending they are all an FP32 fallback.","product-core.0671ca362b":"Coverage would mean less if the model still changed systems between development and production. Core keeps model authoring, numerical representation, training, optimisation, inference, dispatch, serving, benchmarking, and replay inside the same computational machine. Quantisation-aware training does not have to be bolted onto a model after training. Knowledge distillation does not have to live in a separate experimental stack. Progressive precision does not have to end in an export into another runtime. The model can be trained according to the representation it is intended to use, and executed by the same system.","product-core.6a6bf24e4d":"Imports and exports remain available where interoperability requires them. They are boundaries around Core. They are not Core's internal architecture. Inside the machine, model authoring, training, inference, numerical representation, dispatch, serving and replay use the same execution system.\n\nA model does not need to cross an exported file merely to move from one internal responsibility to the next. Interchange remains a deliberate edge, with the boundary named rather than hidden.","product-core.e5f2845eab":"Core has two execution postures. Core Native uses Core's Rust-native runtime, hand-tuned kernels, backend dispatcher, training and inference engine, and supported deterministic execution paths, without requiring a licence for the complete Kera system. Core on Kera is available in selected strategic licences. Kera is Dweve's graph-native systems language, compiler, JIT, and heterogeneous execution foundation.","product-core.863ac7043e":"It adds the deeper Kera execution model, advanced lowering, graph fusion, ownership and effect semantics, and the strategic deployment capabilities included in those agreements. Core remains the AI machine in both cases.\n\nKera is the deepest execution foundation beneath it. The optional foundation does not turn Core Native into a partial product: it changes the execution posture for selected licensed deployments, including pure deterministic supported floating paths where Kera fixes the full execution identity.","product-core.e661b34ab3":"Core is the computational machine beneath the Dweve product family. The products solve different problems. They reuse the same machine instead of rebuilding it. Loom uses Core to run cognition across 528 domain specialists. Nexus uses Core to run the specialists inside executable organisations. Spindle uses Core throughout its knowledge pipeline.","product-core.bd87fdd104":"Aura uses Core for local reasoning and development work. Mesh distributes workloads built on Core. Fabric gives people access to the complete system. Selected strategic deployments run Core on Kera.\n\nThose products solve different jobs, but share one numerical, execution and replay machine instead of carrying separate AI foundations. That shared depth lets a product change deployment without rebuilding its model around another runtime.","product-core.497cc9b047":"Core covers the machine-learning stack from the lowest-level bit operations to complete model structures. The significance is not simply the number of functions. Each operation participates in the same type, representation, backend, dispatch, testing, and determinism systems. The operation surface includes bit primitives, arithmetic, vector operations, reductions, transforms, tensor operations, matrix multiplication, convolution, normalisation, activation, attention, losses, optimisation, training support, inference support, graph-level operations, and model-level composition. A binary operation and an FP64 operation are not two unrelated libraries.","product-core.f76edbe5ff":"A scalar implementation and an AVX-512 implementation are not separate products. A training operator and its inference counterpart do not have to meet through an exported file. They inhabit the same machine.\n\nThe scalar path remains the universal implementation and reference target when specialised instructions are absent. Optimised paths are checked against the cell’s declared numerical and replay contract, so a faster kernel is not treated as correct merely because it is faster.","product-core.eb285f91ec":"Core’s numerical estate is not a ladder back to FP32. The registry records 25 registered numerical format families that expand across polarity, signedness, width, exponent structure, fractional layout, scale ownership, packing and backend. Binary includes unipolar and bipolar semantics. Integer includes sub-byte and full-width signed and unsigned paths plus bit planes. Fixed-point includes compact, general, wide and very wide signed and unsigned Q profiles, generic parameterised forms and wider fixed representations. Adaptive includes compact adaptive floats, neural-adaptive forms and adaptive fixed-point.","product-core.e50ccba933":"The floating side is wider than FP8, FP16, BF16, FP32 and FP64. Core also owns compact through wide bfloat profiles, block-scaled and microscaled formats, mixed-precision execution profiles and software-defined floating types. These are real operator families, not a conversion into one centre.\n\nA bipolar operation is not unipolar with a label changed. A bfloat path is not ordinary float behind a cast. A microscaled block retains its scale ownership. Representation is part of dispatch, verification and replay.","product-core.26a6509c6e":"Scalar code is often described as a fallback. In Core it is the universal implementation and the reference target. It keeps an operation available where specialised instructions are absent and gives every optimised path a stable floor. For covered binary, ternary, integer, fixed-point, adaptive and exact cells, that reference participates in the pure deterministic contract without a seed.","product-core.5b739a92b8":"Floating, bfloat, block-scaled and microscaled paths are compared according to the selected execution foundation. Under Core Native, the scalar and optimised paths are checked through seeded replay and the cell’s declared numerical tolerance.\n\nUnder Core on Kera, supported paths in those families can be checked for pure deterministic identity because Kera fixes graph identity, operation order and reduction topology. The fastest target never defines correctness merely because it is fastest.","product-core.bb1a1782ec":"Core includes a real binary neural-network training system. The output is not a conventional model compressed by an unrelated deployment tool. The target representation participated in the learning process, because efficient execution begins in the model lifecycle, not at the final export step. A binary model can train in its target representation through quantisation-aware methods. A full-precision teacher can supervise a low-bit student through distillation. Progressive precision can move a model down through numerical stages.","product-core.b918a404cb":"Optimiser behaviour can be adapted to low-bit training. Core’s training estate includes the supported optimiser and quantisation-aware paths needed to make the target representation part of learning rather than a last-minute deployment conversion.\n\nA full-precision teacher can supervise a low-bit student through distillation, and progressive precision can move a model through numerical stages. The result is still a Core model with a declared representation and execution contract.","product-core.2f4dba4817":"Core is available through Rust and Python. Both surfaces describe Core models. They do not define separate execution architectures. The language is a front door. The machine behind it remains Core. Rust provides direct control, static types, native integration, standalone binaries, thread and memory control, and access to the system without a language runtime in production.","product-core.4cef5b560f":"Python provides rapid model development, ecosystem integration, array interchange, model import and export, and familiar research workflows. It is a surface for describing Core models, not a separate execution architecture. The declared execution contract stays with Core.\n\nThe same model can reach the Core machine through Rust when direct control, native integration, standalone binaries, thread and memory control matter, or through Python when rapid iteration and ecosystem work are the right fit.","product-core.0cf3c5aba0":"Core on Kera is the optional execution foundation available in selected strategic licence packages. Core supplies the complete AI and machine-learning operation universe. Kera supplies the graph-native language and intermediate representation, advanced lowering, graph fusion, a custom JIT, and a heterogeneous execution model.","product-core.8dd79d1c24":"The distinction is not merely compilation depth. Kera fixes the complete execution identity: graph content, canonical operation order, reduction topology, effect order, lowering decisions, memory ownership and scale-bearing block schedule.\n\nThat makes supported floating, bfloat, block-scaled and microscaled cells pure deterministic without a seed, while preserving the same Core model and representation contracts. Without Kera, Core Native remains complete and uses seeded replay for those families.","product-core.918a228f98":"Many systems expose a quantised datatype but hide the arithmetic model behind it. Core separates the value representation from the way intermediate results are accumulated. This is not a global framework switch. The choice belongs to the operator. That makes mixed numerical models explicit, inspectable, and compilable. A packed binary input may use integer population counts. A low-bit integer operation may accumulate into Int32. A fixed-point operation may use a wider fixed-point accumulator.","product-core.44f4026861":"A half-precision operation may use a higher-precision accumulation path where accuracy requires it. Exact routing may use Numerus-backed arithmetic where the execution contract demands it. Those are separate execution decisions.\n\nStorage representation and accumulator are recorded separately: one defines how values move, the other how intermediate work is carried. Keeping that choice with the operation leaves a mixed numerical model explicit, inspectable and available to dispatch and verification.","product-core.33f2153ae1":"A hand-tuned kernel is not merely a faster function. It is the machine-level acknowledgement that different execution cells are different problems. The abstract operation remains the same. The kernel is written for the target that will actually execute it. Binary matrix multiplication on AVX-512 can use VPOPCNTDQ across wide lanes. Binary operations on NEON use the bit-counting and vector paths available to ARM.","product-core.250482b8d7":"AVX2 kernels are shaped around 256-bit vectors. Scalar kernels provide the universal and reference implementation. CUDA paths are designed around warps. ROCm paths account for AMD wavefront execution. Metal uses Apple's compute model.\n\nVulkan and WebGPU target their respective shader environments. WASM paths account for browser and portable SIMD constraints. These are distinct supported paths selected by dispatch for the current cell; none silently becomes the definition of the model or the sole correctness reference.","product-core.2405eccded":"When useful AI can run on the machine in front of you or on servers controlled nearby, less work has to travel to a distant data centre. Not every AI task will always run entirely on one laptop. But Core gives Dweve far more freedom to keep work local than a system built only for remote accelerator clusters. Your files can remain on your device for supported local tasks. An organisation can keep processing inside its own data centre. A hospital or public service can run a system inside the environment where its rules already apply.","product-core.b5fe3b4db4":"A feature can continue working when a permanent internet connection is not required. Where the product, model and deployment support it, Core can keep the work on the device or in nearby infrastructure rather than making every step depend on a remote service.\n\nThis is a deployment choice with declared limits, not a promise that every workload runs offline or that no larger task will ever need a server. When a capability does not have that support, the product can name the dependency instead of masking it.","product-core.fe7f4bbfad":"Core is not something you have to install or learn. It stays underneath the Dweve product you are using. The products feel different because they do different jobs. The machine underneath them is the same. Loom uses it when it thinks through a problem. Nexus uses it when a team of specialists works on your task. Spindle uses it when it processes and protects knowledge.","product-core.793b343cd8":"Fabric uses it when you ask questions, upload files, and run workflows. The product presents the work in familiar terms while Core chooses the supported representation, execution path and location underneath.\n\nThat does not make every task identical or promise the same path everywhere. It means the machine that performs supported work belongs to the same Dweve system instead of being rebuilt for each product.","product-core.b4feb2afd5":"The best path can differ by operation, datatype, packing, tensor shape, alignment, policy and available instruction set. Core’s dispatcher resolves the implementation at runtime for the current host and execution contract. The decision stays attached to the operation, not to the model as a whole. The selected path is recorded with its cell, host and reason, so a completed run can be inspected rather than assumed. One process may hold an AVX-512 binary kernel and a GPU floating-point path at the same time.","product-core.e2f999a63c":"Core’s claims are designed to be tested on the customer’s hardware. Census and capability checks confirm which numerical, packing and operation families are present, then state whether the selected cell is native, covered by another path, available as device code or unavailable for a named reason.","product-core.83379ce8de":"The selected path is recorded with the cell, host and reason, so a run can be inspected after it completes. Dispatch becomes part of the evidence instead of an invisible runtime choice.\n\nOne process may select an AVX-512 binary kernel, an AVX2 integer path, an exact scalar check and a GPU floating-point path. Each operation keeps its own contract while the model remains one system.","product-core.dd778116ad":"Dispatch tests name the implementation, execution foundation and host that actually ran. Scalar comparison then checks the optimised result against the cell’s declared numerical contract.\n\nReplay closes the record by verifying the pure or seeded promise that the cell declared. The evidence therefore covers availability, selection, numerical agreement and repeatability on the machine that matters.","product-core.dda5c0ace4":"One complete AI compute stack,","product-core.685b4a098b":"every execution path owned","product-core.banner.status.received":"RECEIVED","product-core.banner.status.identified":"IDENTIFIED","product-core.banner.status.selected":"SELECTED","product-core.banner.status.returned":"RETURNED","product-core.banner.status.elsewhere":"ELSEWHERE","product-core.banner.status.inTransit":"IN TRANSIT","product-core.banner.status.staysHere":"STAYS HERE","product-core.banner.status.runsLocally":"RUNS LOCALLY","product-core.banner.status.notRequired":"NOT REQUIRED","product-core.banner.status.mayNeedServer":"MAY NEED SERVER","product-core.banner.status.handled":"HANDLED","product-core.banner.status.recorded":"RECORDED","product-core.banner.status.newTool":"NEW TOOL","product-core.banner.status.newRuntime":"NEW RUNTIME","product-core.banner.status.retained":"RETAINED","product-core.banner.status.unchanged":"UNCHANGED","product-core.banner.status.unsupported":"UNSUPPORTED","product-core.banner.status.extraRuntime":"EXTRA RUNTIME","product-core.banner.status.failed":"FAILED","product-core.banner.status.reopened":"REOPENED","product-core.banner.status.declared":"DECLARED","product-core.banner.status.named":"NAMED","product-core.banner.status.verifiable":"VERIFIABLE","product-core.banner.status.inScope":"IN SCOPE","product-core.banner.status.customerControlled":"CUSTOMER CONTROLLED","product-core.banner.status.available":"AVAILABLE","product-core.banner.status.supportedTarget":"SUPPORTED TARGET","product-core.banner.status.builtHere":"BUILT HERE","product-core.banner.status.evidenceRequired":"EVIDENCE REQUIRED","product-core.banner.status.explicit":"EXPLICIT","product-core.banner.status.separate":"SEPARATE","product-core.banner.status.unstated":"UNSTATED","product-core.banner.status.resolved":"RESOLVED","product-core.banner.status.checked":"CHECKED","product-core.banner.status.compared":"COMPARED","product-core.banner.status.verified":"VERIFIED","product-core.banner.status.direct":"DIRECT","product-core.banner.status.coreModel":"CORE MODEL","product-core.banner.status.rapid":"RAPID","product-core.banner.status.included":"INCLUDED","product-core.banner.status.optionalLicence":"OPTIONAL LICENCE","product-core.banner.status.fixed":"FIXED","product-core.banner.status.boundary":"BOUNDARY","product-core.banner.consumer.local.tag":"HIDDEN CHAIN","product-core.banner.business.requirement.tag":"DEPENDENCY TRACE","product-core.banner.engineering.coverage.tag":"MISSING CONTRACT","product-core.banner.consumer.route.eyebrow":"What changes underneath","product-core.banner.consumer.route.lead":"One request can use","product-core.banner.consumer.route.accent":"the right kind of work.","product-core.banner.consumer.route.body1":"A Dweve product can ask Core for the operation it needs without asking you to choose a number format, processor or runtime.","product-core.banner.consumer.route.body2":"Core keeps those choices inside one machine, so the product can change the path without changing what you asked it to do.","product-core.banner.consumer.route.panel":"One request, handled underneath","product-core.banner.consumer.route.tag":"AUTOMATIC ROUTE","product-core.banner.consumer.route.item1":"Your request arrives","product-core.banner.consumer.route.item2":"The task is understood","product-core.banner.consumer.route.item3":"A supported path is chosen","product-core.banner.consumer.route.item4":"The result comes back","product-core.banner.consumer.route.verdictLabel":"What you choose","product-core.banner.consumer.route.verdict":"The task, not the machinery.","product-core.banner.consumer.boundary.eyebrow":"When the machine stays close","product-core.banner.consumer.boundary.lead":"Useful AI needs","product-core.banner.consumer.boundary.accent":"fewer hidden journeys.","product-core.banner.consumer.boundary.body1":"For a supported local task, your file can remain on the device and the work can continue without sending every step to a distant service.","product-core.banner.consumer.boundary.body2":"The product should also say when a larger task needs a server. Local execution is a supported route, not a blanket promise.","product-core.banner.consumer.boundary.panel":"The local boundary","product-core.banner.consumer.boundary.tag":"HONEST SCOPE","product-core.banner.consumer.boundary.left":"ON YOUR DEVICE","product-core.banner.consumer.boundary.right":"WHEN MORE IS NEEDED","product-core.banner.consumer.boundary.item1":"Your file","product-core.banner.consumer.boundary.item2":"Supported local work","product-core.banner.consumer.boundary.item3":"A permanent connection","product-core.banner.consumer.boundary.item4":"A larger workload","product-core.banner.consumer.boundary.verdictLabel":"The honest promise","product-core.banner.consumer.boundary.verdict":"Local where supported. Clear when not.","product-core.banner.consumer.answer.eyebrow":"What reaches you","product-core.banner.consumer.answer.lead":"The machinery disappears,","product-core.banner.consumer.answer.accent":"but its rules do not.","product-core.banner.consumer.answer.body1":"You do not have to choose the format, packing method or processor instruction. Core makes those choices under the product's declared rules.","product-core.banner.consumer.answer.body2":"That keeps the interface simple without making the work unaccountable. The product can still state where a supported task ran and which path it used.","product-core.banner.consumer.answer.panel":"A simple request receipt","product-core.banner.consumer.answer.tag":"VISIBLE RESULT","product-core.banner.consumer.answer.item1":"You ask for the work","product-core.banner.consumer.answer.item2":"The product handles the choices","product-core.banner.consumer.answer.item3":"Core records the route","product-core.banner.consumer.answer.item4":"You receive the answer","product-core.banner.consumer.answer.verdictLabel":"Your part","product-core.banner.consumer.answer.verdict":"Ask for the work. Use the answer.","product-core.banner.business.change.eyebrow":"The decision behind coverage","product-core.banner.business.change.lead":"A technical change should not","product-core.banner.business.change.accent":"reopen the supplier stack.","product-core.banner.business.change.body1":"Core keeps representation, packing, accumulation, backend and replay decisions inside one implemented system. A new constraint changes the selected execution cell, not the owner of the model.","product-core.banner.business.change.body2":"That removes a familiar source of change cost: another exporter, runtime, vendor review and operating boundary whenever hardware or policy changes.","product-core.banner.business.change.panel":"One changed condition","product-core.banner.business.change.tag":"OWNERSHIP TEST","product-core.banner.business.change.left":"FRAGMENTED STACK","product-core.banner.business.change.right":"CORE BOUNDARY","product-core.banner.business.change.item1":"New numerical requirement","product-core.banner.business.change.item2":"New hardware target","product-core.banner.business.change.item3":"Operation meaning","product-core.banner.business.change.item4":"Computational owner","product-core.banner.business.change.verdictLabel":"Commercial consequence","product-core.banner.business.change.verdict":"Change the condition without rebuilding the stack.","product-core.banner.business.evidence.eyebrow":"From capability to evidence","product-core.banner.business.evidence.lead":"A support badge stays vague until","product-core.banner.business.evidence.accent":"the executed path is named.","product-core.banner.business.evidence.body1":"Core can tie a run to its operation, representation, accumulator, backend, instruction path and replay contract.","product-core.banner.business.evidence.body2":"That turns coverage into evidence engineering can verify and governance can inspect, rather than a broad claim procurement has to accept on trust.","product-core.banner.business.evidence.panel":"The execution record","product-core.banner.business.evidence.tag":"REVIEWABLE","product-core.banner.business.evidence.item1":"Model definition","product-core.banner.business.evidence.item2":"Numerical contract","product-core.banner.business.evidence.item3":"Kernel and host","product-core.banner.business.evidence.item4":"Replay record","product-core.banner.business.evidence.verdictLabel":"Review answer","product-core.banner.business.evidence.verdict":"The path that ran can be named.","product-core.banner.business.deployment.eyebrow":"Move the deployment, not the model","product-core.banner.business.deployment.lead":"Change the operating posture","product-core.banner.business.deployment.accent":"without rewriting the model.","product-core.banner.business.deployment.body1":"A licensed team can operate Core on controlled workstations or clusters, at supported edge targets, or in an isolated estate where the agreement covers that posture.","product-core.banner.business.deployment.body2":"The licence and capability record define the supported scope. Moving the work does not require the organisation to rebuild the AI system around another runtime.","product-core.banner.business.deployment.panel":"Supported operating postures","product-core.banner.business.deployment.tag":"LICENCE SCOPE","product-core.banner.business.deployment.item1":"Controlled workstation","product-core.banner.business.deployment.item2":"Organisation-controlled cluster","product-core.banner.business.deployment.item3":"Isolated estate","product-core.banner.business.deployment.item4":"Local or edge target","product-core.banner.business.deployment.verdictLabel":"What remains","product-core.banner.business.deployment.verdict":"The Core model and its execution contract.","product-core.banner.business.control.eyebrow":"European control, below the application","product-core.banner.business.control.lead":"Sovereignty reaches","product-core.banner.business.control.accent":"the machine that runs the work.","product-core.banner.business.control.body1":"Core is designed and built in the Netherlands and licensed for direct operation on customer-controlled systems, including supported isolated deployments.","product-core.banner.business.control.body2":"That gives governance a technical boundary to inspect, place and operate. European origin does not create compliance by itself; the organisation still owns its rules, evidence and deployment decisions.","product-core.banner.business.control.panel":"The control boundary","product-core.banner.business.control.tag":"NO SHORTCUTS","product-core.banner.business.control.item1":"Technical origin","product-core.banner.business.control.item2":"Operating systems","product-core.banner.business.control.item3":"Isolation posture","product-core.banner.business.control.item4":"Compliance case","product-core.banner.business.control.verdictLabel":"What Core provides","product-core.banner.business.control.verdict":"Control to build the evidence, not a compliance shortcut.","product-core.banner.engineering.cell.eyebrow":"The cell is the contract","product-core.banner.engineering.cell.lead":"A datatype name cannot define","product-core.banner.engineering.cell.accent":"an exact execution cell.","product-core.banner.engineering.cell.body1":"An operation's semantics also depend on width, packing, accumulator, backend, instruction path, dispatch policy and determinism contract.","product-core.banner.engineering.cell.body2":"Core records those dimensions separately, so a low-bit path does not become float behind a cast and storage does not silently define accumulation.","product-core.banner.engineering.cell.panel":"One implemented cell","product-core.banner.engineering.cell.tag":"REGISTRY CONTRACT","product-core.banner.engineering.cell.item1":"Operation semantics","product-core.banner.engineering.cell.item2":"Representation and packing","product-core.banner.engineering.cell.item3":"Accumulator contract","product-core.banner.engineering.cell.item4":"Backend and instruction path","product-core.banner.engineering.cell.item5":"Dispatch and replay contract","product-core.banner.engineering.cell.verdictLabel":"Registry unit","product-core.banner.engineering.cell.verdict":"One concrete, implemented execution cell.","product-core.banner.engineering.dispatch.eyebrow":"Dispatch does not redefine correctness","product-core.banner.engineering.dispatch.lead":"The host chooses a path under","product-core.banner.engineering.dispatch.accent":"the contract that defines correctness.","product-core.banner.engineering.dispatch.body1":"Runtime dispatch selects a supported implementation per operation for the current host and policy. The scalar path remains the universal implementation and reference floor.","product-core.banner.engineering.dispatch.body2":"Optimised kernels are checked against the cell's numerical and replay contract. A faster target is not accepted merely because it is faster.","product-core.banner.engineering.dispatch.panel":"Per-operation dispatch","product-core.banner.engineering.dispatch.tag":"RUNTIME DECISION","product-core.banner.engineering.dispatch.item1":"Resolve the execution cell","product-core.banner.engineering.dispatch.item2":"Check host capability","product-core.banner.engineering.dispatch.item3":"Select the implementation","product-core.banner.engineering.dispatch.item4":"Compare with the reference path","product-core.banner.engineering.dispatch.item5":"Verify the declared replay mode","product-core.banner.engineering.dispatch.verdictLabel":"Correctness anchor","product-core.banner.engineering.dispatch.verdict":"The cell contract, not the fastest host.","product-core.banner.engineering.surfaces.eyebrow":"One model, two language surfaces","product-core.banner.engineering.surfaces.lead":"Rust and Python describe","product-core.banner.engineering.surfaces.accent":"the same Core machine.","product-core.banner.engineering.surfaces.body1":"Rust provides direct control, static types and native integration. Python provides rapid model development and familiar ecosystem workflows.","product-core.banner.engineering.surfaces.body2":"Neither language defines a separate execution architecture. The model's representation and declared execution contract remain with Core.","product-core.banner.engineering.surfaces.panel":"Two front doors","product-core.banner.engineering.surfaces.tag":"ONE RUNTIME CONTRACT","product-core.banner.engineering.surfaces.item1":"Native integration and control","product-core.banner.engineering.surfaces.item2":"Core execution model","product-core.banner.engineering.surfaces.item3":"Research and ecosystem iteration","product-core.banner.engineering.surfaces.item4":"Core execution model","product-core.banner.engineering.surfaces.verdictLabel":"Shared result","product-core.banner.engineering.surfaces.verdict":"One model reaches one Core machine.","product-core.banner.engineering.foundations.eyebrow":"Two execution foundations","product-core.banner.engineering.foundations.lead":"Core Native stays complete as","product-core.banner.engineering.foundations.accent":"Kera adds execution depth.","product-core.banner.engineering.foundations.body1":"Core Native includes the Rust-native runtime, training and inference engines, tuned kernels, dispatch and the supported pure or seeded replay contracts.","product-core.banner.engineering.foundations.body2":"Selected strategic licences add Core on Kera, which fixes graph identity, operation order and reduction topology for pure deterministic supported floating-family paths.","product-core.banner.engineering.foundations.panel":"What each foundation changes","product-core.banner.engineering.foundations.tag":"LICENCE BOUNDARY","product-core.banner.engineering.foundations.item1":"Core Native runtime and engines","product-core.banner.engineering.foundations.item2":"Native replay contract per cell","product-core.banner.engineering.foundations.item3":"Core on Kera foundation","product-core.banner.engineering.foundations.item4":"Graph and reduction identity","product-core.banner.engineering.foundations.verdictLabel":"Stable layer","product-core.banner.engineering.foundations.verdict":"The Core model and representation contracts.","product-core.banner.engineering.verification.eyebrow":"Interchange is an edge, not internal glue","product-core.banner.engineering.verification.lead":"Import the model, then","product-core.banner.engineering.verification.accent":"verify the path that runs.","product-core.banner.engineering.verification.body1":"Import and export remain explicit boundaries around Core. Inside that boundary, capability state, dispatch choice and replay contract belong to the executed cell.","product-core.banner.engineering.verification.body2":"The verification path names unavailable cells with a reason, records the selected implementation, compares it with the scalar reference and checks the replay contract on the target machine.","product-core.banner.engineering.verification.panel":"Execution evidence","product-core.banner.engineering.verification.tag":"RUNNABLE RECORD","product-core.banner.engineering.verification.item1":"Import or export edge","product-core.banner.engineering.verification.item2":"Capability state","product-core.banner.engineering.verification.item3":"Dispatch record","product-core.banner.engineering.verification.item4":"Scalar comparison","product-core.banner.engineering.verification.item5":"Replay check","product-core.banner.engineering.verification.verdictLabel":"Evidence object","product-core.banner.engineering.verification.verdict":"The executed cell on the machine that matters.","product-core.sideTag.allOfThem":"ALL OF THEM","product-core.sideTag.perJob":"PER JOB","product-core.sideTag.ordinary":"ORDINARY","product-core.sideTag.close":"CLOSE","product-core.sideTag.stillOn":"STILL ON","product-core.sideTag.lighter":"LIGHTER","product-core.sideTag.shown":"SHOWN","product-core.sideTag.honest":"HONEST","product-core.sideTag.heldHere":"HELD HERE","product-core.sideTag.handled":"HANDLED","product-core.sideTag.nineDimensions":"9 DIMENSIONS","product-core.sideTag.insideCore":"INSIDE CORE","product-core.sideTag.firstClass":"FIRST-CLASS","product-core.sideTag.siblings":"SIBLINGS","product-core.sideTag.owned":"OWNED","product-core.sideTag.oneSystem":"ONE SYSTEM","product-core.sideTag.determinism":"DETERMINISM","product-core.sideTag.together":"TOGETHER","product-core.sideTag.twoPostures":"2 POSTURES","product-core.sideTag.portable":"PORTABLE","product-core.sideTag.control":"CONTROL","product-core.sideTag.inherited":"INHERITED","product-core.sideTag.sixTiers":"6 TIERS","product-core.sideTag.separated":"SEPARATED","product-core.sideTag.layouts":"LAYOUTS","product-core.sideTag.perTarget":"PER TARGET","product-core.sideTag.resolved":"RESOLVED","product-core.sideTag.ledger":"LEDGER","product-core.sideTag.anchored":"ANCHORED","product-core.sideTag.oneContract":"ONE CONTRACT","product-core.sideTag.native":"NATIVE","product-core.sideTag.twoDoors":"2 DOORS","product-core.sideTag.included":"INCLUDED","product-core.sideTag.licensed":"LICENSED","product-core.sideTag.edges":"EDGES","product-core.sideTag.runnable":"RUNNABLE","product-core.7bd00d4aa5":"The complete machine","product-core.2e403de2e1":"behind every product","product-core.e038ce7971":"Bring the constraint","product-core.7969de36b5":"that breaks your current stack","product-core.8ffffa7c6d":"Bring one combination","product-core.96e545dfe7":"nothing else supports","crx-dependency-deed.47b41000f2":"The deed behind one model","crx-dependency-deed.6b28a1dfeb":"inspected","crx-dependency-deed.70c2e19092":"who owns what","crx-dependency-deed.fd0ab7fbca":"your-model.bin","crx-dependency-deed.285c1432cd":"owned by you","crx-dependency-deed.d7d43f23b6":"numerical library","crx-dependency-deed.e93236a31f":"accelerator runtime","crx-dependency-deed.08b575c9be":"hardware vendor","crx-dependency-deed.461530cd7a":"quantisation tool","crx-dependency-deed.6a378bcc9c":"serving stack","crx-dependency-deed.8d2f6a76a1":"vendor-held","crx-dependency-deed.4be22a0576":"pull one supplier out and the execution chain breaks","crx-dependency-deed.be0fe5c983":"with Core, the operational rights return to one machine","crx-dependency-deed.9439d9f9fc":"the artefact was never the problem","crx-dependency-deed.0faa40a239":"the rights around it were","crx-dependency-deed.76a2979f54":"title deed","crx-dependency-deed.b01dc1bae4":"parcel CORE-9F2A","crx-dependency-deed.630b87bef9":"the model file is held outright by the operator","crx-dependency-deed.820ef29455":"held by you","crx-dependency-deed.0ca0845813":"schedule of encumbrances","crx-dependency-deed.32d59f2421":"operational right","crx-dependency-deed.781b6d09cc":"if the holder pulls out","crx-dependency-deed.1ee2d8317b":"the numbers stop resolving","crx-dependency-deed.22b6f9d92a":"no kernel gets chosen","crx-dependency-deed.f03c29503d":"the model cannot move machine","crx-dependency-deed.8cac54602f":"the compression is lost","crx-dependency-deed.e7adac8090":"nothing serves the result","crx-coverage-map.f94a59f906":"A slice through the engine","crx-coverage-map.70a5e778af":"implemented","crx-coverage-map.d748ed282c":"representative routes across target families","crx-coverage-map.45d86b99db":"One engine owns every shown route","crx-coverage-map.7d61c13ed4":"binary GEMM on AVX-512","crx-coverage-map.817f624193":"int8 conv on NEON","crx-coverage-map.186456c935":"fixed-point on scalar","crx-coverage-map.7523c51a1c":"adaptive fixed-point on WebGPU","crx-coverage-map.4d1c90baf1":"Outside this readable slice","crx-coverage-map.e508092042":"numerical width","crx-coverage-map.0fd2241a81":"implementation path","crx-coverage-map.17f3b48034":"target family","crx-coverage-map.577360a1c0":"dispatch path","crx-coverage-map.350e19548f":"replay contract","crx-coverage-map.ce7c57884a":"verification record","crx-coverage-map.d75cab23f4":"Every cell shown is implemented. The full registry is orders of magnitude larger than this visual.","crx-coverage-map.480d303d95":"one engine owns the matrix","crx-coverage-map.272d5df618":"not a capability boundary","crx-coverage-map.7a1aef5f53":"matrix multiply","crx-coverage-map.ed9ca14839":"convolution","crx-coverage-map.b43cc86e50":"reduction","crx-coverage-map.d0278de5f6":"attention","crx-coverage-map.94acc84132":"quantise","crx-coverage-map.7b423a4d0b":"AVX-512","crx-coverage-map.5f305d0313":"NEON","crx-coverage-map.87e93c3619":"scalar","crx-coverage-map.f5ffade173":"WebGPU","crx-coverage-map.a6a6318544":"GPU","crx-coverage-map.b0d51b9ff9":"deploy","crx-coverage-map.876fb9d636":"operation families","crx-coverage-map.2ce08af9d4":"execution targets","crx-coverage-map.6f0f3f31ce":"implemented inside Core","crx-coverage-map.29e6b05569":"outside this view","crx-coverage-map.60737e49cd":"The scale behind this readable slice","crx-coverage-map.4e58ac7873":"records","crx-coverage-map.0b1ede0118":"representative intersections only","crx-coverage-map.f27b1d5de6":"PC and server processors","crx-coverage-map.d313dff0d2":"phones and ARM devices","crx-coverage-map.a76783e1d4":"GPUs","crx-coverage-map.e7ab5809a7":"browsers","crx-coverage-map.1741ae74b6":"FPGA cards","crx-coverage-map.54a51da1f1":"deploy targets","crx-coverage-map.1c3a7b7dcb":"Target columns name broad families; each family contains many architectures, instruction sets and implementations.","crx-coverage-map.scale.operations":"operations","crx-coverage-map.scale.categories":"operation categories","crx-coverage-map.scale.formats":"numerical formats","crx-coverage-map.scale.dimensions":"execution dimensions","crx-constraint-tunnel.5fec7c3037":"One algorithm, five changing constraints","crx-constraint-tunnel.825aa17056":"surviving","crx-constraint-tunnel.e54ec5ba88":"identity unbroken","crx-constraint-tunnel.9efe229bf2":"the same algorithm","crx-constraint-tunnel.7c2212b429":"binary storage","crx-constraint-tunnel.394056dcb7":"fixed-point accumulator","crx-constraint-tunnel.96709a720d":"AVX2 host","crx-constraint-tunnel.54310964b5":"browser deployment","crx-constraint-tunnel.5df1c23ef8":"pure replay","crx-constraint-tunnel.173f7af069":"the Core identity line runs through all five","crx-constraint-tunnel.312ef3f600":"conditions change around it","crx-constraint-tunnel.b670febe02":"the model never changes owners","crx-constraint-tunnel.986dfb38d9":"algo-7c","crx-constraint-tunnel.afad9a6976":"condition","crx-constraint-tunnel.58b6e8c362":"Core identity line","crx-constraint-tunnel.a1da01a2f9":"unbroken across all five","crx-constraint-tunnel.d3be51ed19":"enters","crx-constraint-tunnel.4fc66ce5aa":"same model leaves","crx-constraint-tunnel.ac5d84bfae":"stage","crx-model-floorplan.4bfffd14a3":"One model, mixed materials","crx-model-floorplan.b746d79201":"mixed","crx-model-floorplan.c6cd731127":"per-operation choice","crx-model-floorplan.2c04c9f4c1":"Binary room","crx-model-floorplan.b13fc66064":"packed tight, minimal energy","crx-model-floorplan.eed69d4b42":"Integer room","crx-model-floorplan.e5d86d4768":"low-bit, correct overflow","crx-model-floorplan.1cb503e426":"Fixed-point room","crx-model-floorplan.1eddeb6036":"exact rulers on every wall","crx-model-floorplan.f6ce308fda":"Adaptive fixed-point room","crx-model-floorplan.ea5560baac":"range chosen through integer and fixed-point profiles","crx-model-floorplan.15be351c04":"every room connects through the same Core structure","crx-model-floorplan.84c8a2b7a5":"no room is an extension","crx-model-floorplan.a54ec2a121":"no format is a fallback","crx-model-floorplan.d28f8294a7":"one Core structure","crx-model-floorplan.ebf2dcb9a9":"room width tracks each part's share of the model, storage and accumulation are separate walls","crx-model-floorplan.3a21295d81":"store","crx-model-floorplan.da612b0004":"accumulate","crx-model-floorplan.c510bd86c3":"1-bit","crx-model-floorplan.d71739707a":"int32","crx-model-floorplan.b74777c55d":"int8","crx-model-floorplan.9e07348cfb":"Q16.16","crx-model-floorplan.b55e22fe78":"exact","crx-model-floorplan.d7e3c028b8":"Q8.8 adaptive","crx-model-floorplan.f0a9f86c3e":"Q16.16 accumulator","crx-model-floorplan.55c1ef9ce7":"model floor plan","crx-model-floorplan.4f44e2cffa":"compact","crx-model-floorplan.78cd1257c3":"moderate","crx-model-floorplan.29715c1826":"spacious","crx-roundhouse.011076d2d5":"The operation and its destinations","crx-roundhouse.ecf60a07c3":"routing","crx-roundhouse.f94f7fdfdb":"no central sun","crx-roundhouse.47e02a1ac9":"one abstract operation","crx-roundhouse.10d5e48d4d":"x86 SIMD","crx-roundhouse.1796ed4ac9":"ARM + Apple silicon","crx-roundhouse.979d2b45bb":"NVIDIA / AMD / Apple GPU","crx-roundhouse.c378fd4d91":"WebAssembly / WebGPU","crx-roundhouse.d3cc0d9505":"deployment hardware","crx-roundhouse.2eed29d429":"route chosen by host and policy","crx-roundhouse.444d1ac3e4":"the processor is a destination","crx-roundhouse.09c0d71ba2":"never the owner","crx-roundhouse.86dd1cf451":"host","crx-roundhouse.9f00fad98b":"policy","crx-roundhouse.1d3cdb9541":"best available path","crx-roundhouse.bdf70eff0e":"dispatcher","crx-roundhouse.9d47e57447":"selected route","crx-roundhouse.c65a0fb7e7":"kernel","crx-roundhouse.c39a348c72":"pick a host to see the route","crx-roundhouse.464257ea7f":"x86 server","crx-roundhouse.1ca349b520":"Apple or ARM laptop","crx-roundhouse.96cfcc61c7":"GPU node","crx-roundhouse.95a683543a":"browser tab","crx-roundhouse.465bcea812":"edge device","crx-roundhouse.03817c1688":"AVX2 or AVX-512","crx-roundhouse.29ae7f8fca":"NEON native","crx-roundhouse.fe64fe852c":"CUDA or ROCm","crx-roundhouse.bc43997fb5":"WASM or WebGPU","crx-roundhouse.cfb6609c33":"deployment kernel","crx-watch-cells.5b781cec05":"Three cells, opened","crx-watch-cells.80dca10314":"hand-tuned","crx-watch-cells.14544365cf":"coverage is code","crx-watch-cells.fd42e8f653":"Binary on AVX-512","crx-watch-cells.e525dd5e9a":"bit instructions, not scaled floats","crx-watch-cells.1cef2b7a6d":"Integer on NEON","crx-watch-cells.3bf2051edf":"native paths, correct accumulator","crx-watch-cells.9d651c54c9":"GPU path","crx-watch-cells.44b6db92b3":"built for the target's execution structure","crx-watch-cells.4691b587d6":"Generic \"supports all\"","crx-watch-cells.5e438aa323":"compiles everywhere, owned nowhere","crx-watch-cells.746b58c54e":"every supported cell has an author","crx-watch-cells.e704c56d22":"and the author owns the result","crx-watch-cells.6acd621280":"pack","crx-watch-cells.81529fbdf9":"instruction","crx-watch-cells.da612b0004":"accumulate","crx-watch-cells.2e96e89125":"emit","crx-watch-cells.78a1767a59":"128-bit packed words","crx-watch-cells.4358ecd77f":"VPOPCNTDQ","crx-watch-cells.d71739707a":"int32","crx-watch-cells.ba2f1b7b58":"dense result","crx-watch-cells.3eaed1d576":"int8, 16 lanes","crx-watch-cells.4a9c4e937f":"SMLAL widening","crx-watch-cells.92c08189e9":"scaled result","crx-watch-cells.1924992d03":"warp tiles","crx-watch-cells.671b6a9406":"warp reduce","crx-watch-cells.0f8429b1a7":"int32","crx-watch-cells.b92fc8f7c9":"tiled result","crx-watch-cells.af78c120ea":"operation x datatype x ISA","crx-watch-cells.6b58e2c0c0":"one loop for everything","crx-watch-cells.20a13a92c2":"kernel movement","crx-model-passport.4042e7f42b":"The model passport","crx-model-passport.bec262808f":"valid","crx-model-passport.9a59c14c33":"one identity throughout","crx-model-passport.f64cd8e32f":"author","crx-model-passport.94efdd6f62":"train","crx-model-passport.86ad49c21f":"optimise","crx-model-passport.df6ad19037":"run","crx-model-passport.b88fb872d7":"serve","crx-model-passport.86a4261d84":"verify","crx-model-passport.93951d9e4c":"same identity, same format, every station","crx-model-passport.e24f9a4d08":"import gate","crx-model-passport.82b2585e5a":"export gate","crx-model-passport.3b34d91e82":"boundaries at the outer edge, never glue between stages","crx-model-passport.bdc429becb":"no owner changes halfway","crx-model-passport.cb300a42e1":"no export between stations","crx-model-passport.ff17c071b4":"holder","crx-model-passport.07e1c96ea6":"model-9f2a","crx-model-passport.785987648f":"format","crx-model-passport.13d8fc3824":"Core native","crx-model-passport.7be3ea3ad7":"issued at","crx-model-passport.19bd79d8b2":"authoring","crx-model-passport.66f5c87193":"authority","crx-model-passport.aaba3850f5":"Dweve Core machine","crx-model-passport.50de66b735":"serial","crx-model-passport.5012d74d18":"CORE-NL-000-9F2A","crx-model-passport.1d06a0d76f":"model","crx-model-passport.4ff7b14e8f":"one passport, stamped at every station","crx-model-passport.662ff7ffd3":"P<CORE<MODEL<9F2A<<AUTHOR<TRAIN<OPTIMISE","crx-model-passport.7232cc6605":"RUN<SERVE<VERIFY<<<<ONE<IDENTITY<<<<<<<<","crx-model-passport.5e855b8dc5":"data page","crx-model-passport.9a6be6aac9":"identity page","crx-model-passport.9e110705d7":"checksum 9f3a…c41d","crx-model-passport.74856a48fa":"authored in Core, never re-issued","crx-model-passport.ee8e2a108b":"no second identity for other machines","crx-contract-selector.7d614bcbd7":"The determinism contract selector","crx-contract-selector.94f00422a0":"per cell","crx-contract-selector.5910d74f46":"three contracts","crx-contract-selector.cae5970fc9":"Pure Core Native","crx-contract-selector.00c9c25059":"pure, seed none","crx-contract-selector.9ad3dc4c49":"Recorded sampling state","crx-contract-selector.0d9bb5b5c2":"integer state and record pinned","crx-contract-selector.df0b6c410f":"Pure Core on Kera","crx-contract-selector.42b66de5c7":"pure integer and fixed-point, seed none","crx-contract-selector.e0708dd7ef":"one Core model; the cell and foundation select the contract","crx-contract-selector.7f43ea969a":"all three return through one dispatcher","crx-contract-selector.929336eb6f":"determinism is stated","crx-contract-selector.f55955b5dc":"not assumed","crx-contract-selector.a96275ffde":"cell and foundation","crx-contract-selector.d3037bea56":"output hash","crx-contract-selector.688efa5901":"0x9f2a...c41","crx-contract-selector.acb39d3f40":"covered internal cell, seed none","crx-contract-selector.92713d4709":"seed","crx-contract-selector.873a8dc09c":"seed 4821","crx-contract-selector.f523a6ccd2":"the complete execution record and seed reproduce the supported path","crx-contract-selector.b4e378ec12":"supported internal cell, seed none","crx-contract-selector.f55fae837b":"graph","crx-contract-selector.40beaa2815":"backend","crx-contract-selector.7fb4d43ad9":"packing","crx-contract-selector.1c9d50dc3f":"sample 1","crx-contract-selector.83ec0ba5c3":"sample 2","crx-contract-selector.d212294e2d":"sample 3","crx-contract-selector.7474b1c6fb":"output artefact","crx-incident-dossier.ea99620328":"The same incident, twice","crx-incident-dossier.b56f08775d":"reviewed","crx-incident-dossier.f7f50285e1":"accountability","crx-incident-dossier.74c66d849d":"Fragmented stack","crx-incident-dossier.8c958d1dec":"framework blames exporter","crx-incident-dossier.ff918d28c5":"exporter blames runtime","crx-incident-dossier.0485495ba8":"runtime blames kernel","crx-incident-dossier.70b34d3189":"kernel blames driver","crx-incident-dossier.783263e20e":"driver blames hardware","crx-incident-dossier.f620dc66c5":"With Core","crx-incident-dossier.8e8263cb89":"the selected path, named","crx-incident-dossier.3a3151b931":"the numeric contract, stated","crx-incident-dossier.f58aedee1c":"the external boundary, identified","crx-incident-dossier.b1dcb28a44":"one dossier","crx-incident-dossier.a5025961fa":"one accountable boundary","crx-two-foundations.1492e03ffd":"One machine, two foundations","crx-two-foundations.3aff6ce8b2":"both real","crx-two-foundations.8be5996074":"honest gates","crx-two-foundations.426518fd77":"the Core surface, identical in both postures","crx-two-foundations.b14e0fee60":"Core Native","crx-two-foundations.bdf5503cde":"Rust kernel chassis","crx-two-foundations.bbd4070f99":"hand-tuned kernels","crx-two-foundations.74ade7aa6b":"dispatcher + engines","crx-two-foundations.274a416211":"broad licence","crx-two-foundations.5bd7bdd9b6":"Core on Kera","crx-two-foundations.a30386a485":"graph-native IR","crx-two-foundations.f39ee801f2":"fusion + custom JIT","crx-two-foundations.914b009acc":"heterogeneous execution","crx-two-foundations.628c0f5690":"selected strategic licences","crx-two-foundations.3336470652":"Core is the machine in both","crx-two-foundations.3c164b6adb":"the depth beneath it differs","crx-deploy-scenes.1989cefc1b":"Four scenes, one stamp","crx-deploy-scenes.bc109fb076":"portable","crx-deploy-scenes.1e592e6615":"posture changes","crx-deploy-scenes.de587e6170":"private cluster","crx-deploy-scenes.4cbd04a536":"your servers","crx-deploy-scenes.7dba68c51f":"edge + browser","crx-deploy-scenes.1b84995dfa":"isolated","crx-deploy-scenes.6d917c2df3":"CORE","crx-deploy-scenes.662321cce4":"inside each scene the dispatcher chooses a different path","crx-deploy-scenes.500f733f62":"unsupported cells stay outlined, never quietly filled","crx-deploy-scenes.780837b346":"the backend moves","crx-deploy-scenes.16a2aa1d2d":"the AI system does not","crx-europe-layers.aa13613b4a":"Control, layer by layer","crx-europe-layers.2c03439596":"held","crx-europe-layers.f85397ec35":"built in the Netherlands","crx-europe-layers.ceb3178ed9":"designed and built in the Netherlands","crx-europe-layers.f178867da2":"framework","crx-europe-layers.e16f7e8d47":"training engine","crx-europe-layers.861e5860fb":"inference system","crx-europe-layers.797640d34f":"numerical model","crx-europe-layers.8bee47f347":"hardware paths","crx-europe-layers.7a47ae3880":"operational record","crx-europe-layers.de587e6170":"licensed estate","crx-europe-layers.f86d095f61":"customer-controlled","crx-europe-layers.1b84995dfa":"isolated","crx-europe-layers.9ba0a8e5a2":"origin does not create compliance, it creates control","crx-europe-layers.b50146e995":"sovereignty begins","crx-europe-layers.b276812aea":"below the application layer","crx-stack-sockets.25ba771800":"Eight products, one machine","crx-stack-sockets.759d3429e2":"inherited","crx-stack-sockets.b487ae8e16":"nothing rebuilt","crx-stack-sockets.0fed3b96cc":"Loom","crx-stack-sockets.15e95a8281":"cognition, 528 domain specialists","crx-stack-sockets.485a04fef4":"Nexus","crx-stack-sockets.c4ac7f5a6c":"executable organisations","crx-stack-sockets.4a86080d67":"Spindle","crx-stack-sockets.bd9ed2df67":"lossless knowledge","crx-stack-sockets.873132a799":"Mesh","crx-stack-sockets.8c60592199":"circular compute","crx-stack-sockets.af0854de67":"Aura","crx-stack-sockets.efc51a8d76":"development agents","crx-stack-sockets.a010de5c61":"Fabric","crx-stack-sockets.d345388d98":"the human surface","crx-stack-sockets.2a48a488e1":"Core, the complete AI machine","crx-stack-sockets.18ce3dacd9":"Kera beneath Core, on licensed paths only","crx-stack-sockets.df36bbade5":"different problems above","crx-stack-sockets.b3207579ca":"one machine below","crx-stack-sockets.53f6adedc3":"product modules","crx-stack-sockets.aabe07b1ec":"one shared computational bus","crx-stack-sockets.2bbb010e92":"seats into Core","crx-stack-sockets.adbe9b4b3d":"licensed paths only","crx-vocab-tower.aee90edc1c":"The vocabulary tower","crx-vocab-tower.0737c22d3b":"complete","crx-vocab-tower.6caf0625aa":"bit to architecture","crx-vocab-tower.4c5cf9b7b9":"bit primitives","crx-vocab-tower.4a4006c0f5":"arithmetic + vectors","crx-vocab-tower.088801dc7d":"tensors + BLAS","crx-vocab-tower.6b7196de29":"neural operations","crx-vocab-tower.84875956e9":"training + inference","crx-vocab-tower.9efcaef942":"graphs + models","crx-vocab-tower.4e8018aaf0":"convolution, opened","crx-vocab-tower.8f289fe6b3":"binary, integer, fixed-point, adaptive fixed-point","crx-vocab-tower.49aed6b700":"scalar, AVX2, AVX-512, NEON, GPU","crx-vocab-tower.59e0afcd2c":"every category reveals its datatype and backend coverage","crx-vocab-tower.964c871ff9":"one tower","crx-vocab-tower.1d6b8d574e":"no unrelated libraries","crx-format-sockets.05eead62eb":"The operator contract board","crx-format-sockets.70476ec4e2":"plugged","crx-format-sockets.c22af57a09":"external FP stops at the boundary","crx-format-sockets.68bb46d16b":"the operator contract","crx-format-sockets.7e57cfe843":"binary","crx-format-sockets.f974fb78f6":"ternary","crx-format-sockets.9bdb077752":"Int4","crx-format-sockets.9e07348cfb":"Q16.16","crx-format-sockets.89e4165733":"Int8","crx-format-sockets.3bbefcf161":"signed Q","crx-format-sockets.e9ae23f89e":"unsigned Q","crx-format-sockets.b55e22fe78":"exact","crx-format-sockets.01671d01cd":"each internal representation plugs directly into the contract","crx-format-sockets.12289bae9e":"external FP inputs and baselines convert before this board; no internal FP bus exists","crx-format-sockets.38f2580f95":"sockets, not aliases","crx-format-sockets.7abc04f25b":"semantics per plug","crx-accumulator-cards.f6dd3a11a3":"Four operators, opened","crx-accumulator-cards.a45c2264b8":"explicit","crx-accumulator-cards.bd41261724":"storage vs accumulator","crx-accumulator-cards.65258032ee":"Packed binary","crx-accumulator-cards.167512a1cd":"binary words","crx-accumulator-cards.b13ec66246":"population counts","crx-accumulator-cards.98d60989c8":"Low-bit integer","crx-accumulator-cards.bd4e19d042":"Int4 blocks","crx-accumulator-cards.a0e8ac80fb":"Int32 accumulate","crx-accumulator-cards.fce42136e9":"Fixed-point","crx-accumulator-cards.9e07348cfb":"Q16.16","crx-accumulator-cards.52b8fb8f1c":"wider fixed-point","crx-accumulator-cards.f0d05849dc":"Adaptive fixed-point","crx-accumulator-cards.d7e3c028b8":"Q8.8 adaptive","crx-accumulator-cards.2de52e6776":"Q16.16 accumulator","crx-accumulator-cards.3d48292e4d":"storage","crx-accumulator-cards.eae2b5e3f9":"accumulator","crx-accumulator-cards.9d6684203c":"widening and exact routing drawn explicitly, per operator","crx-accumulator-cards.87fc9afe7a":"the value is one contract","crx-accumulator-cards.f96fc235ed":"the sum is another","crx-packing-fold.6cb07c7dd7":"One tensor, four physical truths","crx-packing-fold.682b052d4e":"folded","crx-packing-fold.7252cb1790":"layout is implementation","crx-packing-fold.93950269b6":"one logical tensor","crx-packing-fold.9380a7e132":"packed words","crx-packing-fold.b7bd012d7f":"bit planes","crx-packing-fold.d584c600f2":"quantised blocks","crx-packing-fold.6f465e088d":"vector layout","crx-packing-fold.40adc91772":"bitwise kernel","crx-packing-fold.2bff9133d3":"plane-wise kernel","crx-packing-fold.33309abca2":"block-wise kernel","crx-packing-fold.a8acf566e4":"lane-wise kernel","crx-packing-fold.4561eab16d":"registers, alignment, and reductions visibly match the packing","crx-packing-fold.72956d2bb9":"the layout changes the kernel","crx-packing-fold.0e717d8239":"never hidden behind one claim","crx-kernel-schematics.6e9c8b3b31":"One operator, six machines","crx-kernel-schematics.30a810c2c3":"tuned","crx-kernel-schematics.ff3d93f264":"per-target kernels","crx-kernel-schematics.cc72ce65d0":"the abstract operator","crx-kernel-schematics.7b423a4d0b":"AVX-512","crx-kernel-schematics.8234dc28f9":"VPOPCNTDQ, wide lanes","crx-kernel-schematics.5f305d0313":"NEON","crx-kernel-schematics.e07066db7c":"ARM bit-count paths","crx-kernel-schematics.8f879e930e":"AVX2","crx-kernel-schematics.5906b4f835":"256-bit vectors","crx-kernel-schematics.ae4b69630a":"CUDA","crx-kernel-schematics.54dc761b7f":"warp-shaped execution","crx-kernel-schematics.1024d47ae0":"ROCm / Metal","crx-kernel-schematics.8d15b04c93":"wavefronts, Apple compute","crx-kernel-schematics.9b9f3c4925":"WASM / WebGPU","crx-kernel-schematics.5e36049bcd":"browser constraints respected","crx-kernel-schematics.b137a31e95":"the operator is shared","crx-kernel-schematics.a8295d8292":"the kernel is not generic","crx-coverage-board.d66df1c51f":"A selected execution slice","crx-coverage-board.4c54cc4d8b":"implemented paths","crx-coverage-board.0e20fd16bb":"a readable sample, not the registry","crx-coverage-board.07f151f126":"implemented","crx-coverage-board.3658c742c1":"The actual implementation registry is orders of magnitude larger","crx-coverage-board.995fee1f1a":"outside this view","crx-coverage-board.9076c84c17":"one implementation path","crx-coverage-board.250564c43d":"binary GEMM x AVX-512","crx-coverage-board.efa71d22a5":"gemm_bin_avx512_vpopcnt","crx-coverage-board.7f11a22b58":"dispatch + replay tests attached","crx-coverage-board.eae45da5b6":"scalar remains the functional floor, never a paint bucket","crx-coverage-board.5fbc2abeb0":"inspect the selected path","crx-coverage-board.7abebd5f16":"nine dimensions sit behind every cell","crx-coverage-board.f3e956c179":"operation family","crx-coverage-board.7c7335b41a":"backend target","crx-coverage-board.0a181c0c85":"readable implementation symbol","crx-coverage-board.48a3661d84":"status","crx-coverage-board.65279e1ecf":"verification","crx-coverage-board.caea2c1e02":"Select any shown cell to inspect its path","crx-coverage-board.90b7e751b0":"defined and licensed, outlined until it ships for this target","crx-coverage-board.e65e3fc0da":"path specified, release tests pending","crx-coverage-board.f77aee214f":"no optimised path for this cell","crx-coverage-board.000ee7db0b":"resolves to the scalar reference floor","crx-coverage-board.f8949e9dfd":"Every square shown is implemented. Omitted combinations are outside this readable slice, not marked unsupported.","crx-coverage-board.3312c28857":"dispatch test: expected path selected","crx-coverage-board.fa10ee6b47":"replay: output hash match on this target","crx-coverage-board.0daa14917a":"contract: result within declared tolerance","crx-coverage-board.scale.operations":"operations","crx-coverage-board.scale.categories":"operation categories","crx-coverage-board.scale.formats":"numerical formats","crx-coverage-board.scale.dimensions":"execution dimensions","crx-dispatch-ledger.617886a557":"One process, several backends","crx-dispatch-ledger.026ab2fab0":"resolved","crx-dispatch-ledger.64a5c49d93":"dispatch per operation","crx-dispatch-ledger.92f666dcb7":"binary GEMM","crx-dispatch-ledger.7b423a4d0b":"AVX-512","crx-dispatch-ledger.a9c4e3739b":"int8 conv","crx-dispatch-ledger.8f879e930e":"AVX2","crx-dispatch-ledger.9587eade66":"exact check","crx-dispatch-ledger.87e93c3619":"scalar","crx-dispatch-ledger.27ccef8b30":"adaptive fixed attention","crx-dispatch-ledger.a6a6318544":"GPU","crx-dispatch-ledger.115946fe1f":"The dispatch ledger","crx-dispatch-ledger.f0c87d9b49":"operation, cell, and host recorded","crx-dispatch-ledger.050acc8123":"selected kernel named","crx-dispatch-ledger.780e074772":"verifiable after the run","crx-dispatch-ledger.de27b8df68":"four operations","crx-dispatch-ledger.caa8e1cff3":"four named paths, one process","crx-dispatch-ledger.7948688b7d":"the process, four operations","crx-dispatch-ledger.32f6833db6":"one decision, expanded","crx-dispatch-ledger.6c9e077567":"candidate kernels","crx-dispatch-ledger.19c8306da8":"resolved path","crx-dispatch-ledger.3fe6938286":"chosen","crx-dispatch-ledger.1f087a5954":"rejected","crx-dispatch-ledger.3684c9d3c0":"floor","crx-dispatch-ledger.fcb60bc535":"operation","crx-dispatch-ledger.0698e178c4":"datatype","crx-dispatch-ledger.e9dc3a9121":"tensor shape","crx-dispatch-ledger.05ec087a76":"packing","crx-dispatch-ledger.ae44aad7e6":"host capability","crx-dispatch-ledger.9d128bced6":"input cell","crx-dispatch-ledger.39b36c1208":"select an operation to trace its decision","crx-dispatch-ledger.71dd24f5c8":"512-bit popcount present, packed path","crx-dispatch-ledger.ae8b3023cc":"no 512-bit popcount on this host","crx-dispatch-ledger.2d1c284d56":"correct but unvectorised","crx-dispatch-ledger.99090227f9":"256-bit lanes, int32 accumulate","crx-dispatch-ledger.1bffdf687a":"kernel not present on this host","crx-dispatch-ledger.832f34f253":"reference path, always available","crx-dispatch-ledger.9aa3c66ef8":"deterministic, exact accumulation","crx-dispatch-ledger.a92ed5c681":"reassociation would break exactness","crx-dispatch-ledger.4b04e760b2":"warp-level matmul, fixed-point accumulate","crx-dispatch-ledger.08f6e834f3":"host-side reference","crx-calibration-bench.c4ed65e5dd":"The calibration bench","crx-calibration-bench.1809be6b77":"anchored","crx-calibration-bench.2b551aab9a":"scalar as reference","crx-calibration-bench.0887e0e40a":"Scalar reference","crx-calibration-bench.d7ab790eab":"the trusted trace","crx-calibration-bench.8f879e930e":"AVX2","crx-calibration-bench.7b423a4d0b":"AVX-512","crx-calibration-bench.5f305d0313":"Shader","crx-calibration-bench.a6a6318544":"GPU","crx-calibration-bench.730f5e6eab":"each optimised path compared against the reference, per its contract","crx-calibration-bench.4f0d8db747":"Pure Core on Kera","crx-calibration-bench.7113ab4ad2":"fast paths earn trust","crx-calibration-bench.de5f663b45":"scalar defines correct","crx-calibration-bench.0970c6f5a8":"optimised paths against the scalar reference","crx-calibration-bench.3150ecd5e0":"path","crx-calibration-bench.c65a0fb7e7":"kernel","crx-calibration-bench.57559f5a4f":"max |Δ| vs reference","crx-calibration-bench.d61ceadbdb":"contract","crx-calibration-bench.860360acc7":"verdict","crx-calibration-bench.5fb801f2f3":"accept","crx-calibration-bench.6ea8cadd32":"Pure Core Native","crx-calibration-bench.5bc3d5c013":"Recorded sampling state","crx-calibration-bench.560e82c911":"golden output, hashed and pinned","crx-calibration-bench.e440141fc8":"the calibration loop","crx-calibration-bench.02ab610f42":"reference","crx-calibration-bench.86ad49c21f":"optimise","crx-calibration-bench.b64ca250f4":"compare","crx-calibration-bench.52f584e6f3":"scalar runs the operation","crx-calibration-bench.a90e9bd886":"the target kernel runs beside it","crx-calibration-bench.c43795da2b":"outputs checked per contract","crx-calibration-bench.bb2bd17969":"the fast path earns its place","crx-calibration-bench.4c2ed6ebbb":"op: gemm_bin 512 x 512","crx-calibration-bench.31aaa1dd0b":"seed: none, pure Core Native","crx-calibration-bench.4e04190df2":"hash: 9f3a…c41d pinned","crx-one-vocabulary.02fad1d311":"One operator, four surfaces","crx-one-vocabulary.d18aac96b9":"shared","crx-one-vocabulary.52fdb7a9e1":"no internal exports","crx-one-vocabulary.0546b9b054":"operator definition","crx-one-vocabulary.f178867da2":"framework","crx-one-vocabulary.df1571202e":"authors with it","crx-one-vocabulary.297e1479cf":"trainer","crx-one-vocabulary.131ffd1643":"trains against it","crx-one-vocabulary.c64033672f":"engine","crx-one-vocabulary.67b9c7ee8d":"executes it","crx-one-vocabulary.bdf70eff0e":"dispatcher","crx-one-vocabulary.2c0f16390b":"routes it","crx-one-vocabulary.9dbf26c88c":"each surface reads the same contract; nothing serialises in between","crx-one-vocabulary.0ce01192ba":"one vocabulary","crx-one-vocabulary.c4b79c80c4":"four readers","crx-one-vocabulary.039b3ab56a":"reads the same contract","crx-one-vocabulary.6bfc42cc94":"datatype, packing, accumulator, backend, dispatch","crx-one-vocabulary.947b16772d":"four active surfaces","crx-one-vocabulary.71e8c3aa59":"one contract, four readers","crx-one-vocabulary.a05aa257ef":"change one axis here and every surface below sees the same change","crx-training-routes.a27b6db67b":"Three routes to a low-bit model","crx-training-routes.818cbce922":"converging","crx-training-routes.4061fcf288":"representation in the loop","crx-training-routes.f305658e1a":"QAT","crx-training-routes.82fdef8ac9":"low-bit from step one","crx-training-routes.ef25dd6c09":"distillation","crx-training-routes.915ac51274":"teacher supervises student","crx-training-routes.11834ce00a":"progressive","crx-training-routes.1a3822c90f":"from an external FP baseline, converted before training","crx-training-routes.b3c85352e2":"the low-bit model","crx-training-routes.afc92fa72f":"optimiser state alongside: AdamW, RMSProp, quantised variants","crx-training-routes.0078526d2a":"the representation learned","crx-training-routes.be5676658c":"not compressed afterwards","crx-mode-console.b1e34c701d":"The same call, three contracts","crx-mode-console.94f00422a0":"per cell","crx-mode-console.10a9d7555a":"determinism contracts","crx-mode-console.2fa491aedd":"run(model, cell=adaptive, foundation=native)","crx-mode-console.a3bf7fabff":"output hash 9f2e...c41a, seed none","crx-mode-console.9792637865":"run(model, cell=Q8.8, foundation=native, samplingSeed=42)","crx-mode-console.8c5fc28eb8":"integer sampling state and execution record pinned","crx-mode-console.c1c03afadd":"run(model, cell=Q16.16, foundation=kera)","crx-mode-console.d484c4f77d":"output hash 9f2e...c41a, seed none","crx-mode-console.0ba54182de":"the cell and foundation select the contract; sampling remains separate","crx-mode-console.0243b8f79a":"one dispatch","crx-mode-console.ae3666d0fc":"three honest contracts","crx-two-surfaces.2d283cd25d":"Two languages, one trace","crx-two-surfaces.2ac449ab52":"converged","crx-two-surfaces.1e10728411":"front doors","crx-two-surfaces.e2ae20d9ae":"Rust","crx-two-surfaces.a1e3559f5b":"let m = core::model()?;","crx-two-surfaces.ec239e6ac6":"m.dispatch(host)?;","crx-two-surfaces.6e3604888c":"Python","crx-two-surfaces.e536ed85a6":"m = core.model()","crx-two-surfaces.7fe8078312":"m.dispatch(host)","crx-two-surfaces.e41671fbf4":"one operator graph","crx-two-surfaces.3c7cff80aa":"one dispatch trace","crx-two-surfaces.1feb8ddc4a":"the language changes the call","crx-two-surfaces.7d45db3096":"never the machine","crx-native-chassis.435ed0cdb4":"The Core Native chassis","crx-native-chassis.d226ad3bcd":"exploded","crx-native-chassis.ed4b0d9c81":"Rust-native","crx-native-chassis.09b96abde5":"API surface","crx-native-chassis.c96aa5939e":"model graph","crx-native-chassis.297e1479cf":"trainer","crx-native-chassis.442088cd90":"kernels","crx-native-chassis.bdf70eff0e":"dispatcher","crx-native-chassis.be2ce73e10":"host execution","crx-native-chassis.8f9cf98034":"boundaries explicit, no other AI runtime underneath","crx-native-chassis.afd1a86803":"Core's own execution path","crx-native-chassis.3cb7ff798b":"no wrapper","crx-kera-lowering.aac00062ba":"The same graph, lowered deeper","crx-kera-lowering.6b9f2ddd39":"licensed path","crx-kera-lowering.5bd7bdd9b6":"Core on Kera","crx-kera-lowering.5ac1a6c71e":"Core graph","crx-kera-lowering.dd71d77068":"content-addressed DAG","crx-kera-lowering.f7e6fdf149":"fusion","crx-kera-lowering.f22483b312":"lowering","crx-kera-lowering.6c7b5aa685":"custom JIT","crx-kera-lowering.4683e789c3":"targets","crx-kera-lowering.6c99be637c":"licence boundary: selected strategic packages","crx-kera-lowering.676dd30206":"without Kera, the same model runs on Core Native","crx-kera-lowering.20f383606a":"Core supplies the operations","crx-kera-lowering.fb7a52ff0f":"Kera supplies the depth","crx-kera-lowering.9671fb7e36":"Core operators, one live graph","crx-kera-lowering.01c218d5b1":"content-addressed .keg nodes","crx-kera-lowering.9dff3d75f2":"graph fusion across ops","crx-kera-lowering.61b256ea6d":"advanced lowering","crx-kera-lowering.6b4d0652d7":"custom JIT codegen","crx-kera-lowering.914b009acc":"heterogeneous execution","crx-kera-lowering.4090350f28":"Kera supplies the depth, selected strategic licences","crx-kera-lowering.260ee8d509":"Core Native path","crx-kera-lowering.27f3253e3b":"lowered across the boundary","crx-kera-lowering.21a7b05105":"one model, two depths","crx-sealed-domain.c04349b0fd":"A sealed domain with two doors","crx-sealed-domain.5d2b90a4c4":"sealed","crx-sealed-domain.57e70ec063":"boundaries, not glue","crx-sealed-domain.75021dd13c":"import door","crx-sealed-domain.782190dd5e":"export door","crx-sealed-domain.f178867da2":"framework","crx-sealed-domain.297e1479cf":"trainer","crx-sealed-domain.c64033672f":"engine","crx-sealed-domain.3d36387a86":"backends","crx-sealed-domain.74c691600f":"one live representation inside, no serialising between stages","crx-sealed-domain.f6dce5c9d0":"an imported model becomes a Core model","crx-sealed-domain.84477b8bc8":"an export is a deliberate crossing","crx-sealed-domain.f2f44a22b2":"interchange serves migration","crx-sealed-domain.da91cb1f13":"never the internal architecture","crx-verify-board.12c7c44d52":"The verification board","crx-verify-board.0855694ebb":"runnable","crx-verify-board.ed525355b3":"your hardware","crx-verify-board.d4fca8a041":"$ core test census","crx-verify-board.91ab87254b":"2,900+ operations, 76 categories present","crx-verify-board.c7e516b4ea":"$ core capability --explain","crx-verify-board.f43afbb01b":"native, covered-by, device path, or unavailable with reason","crx-verify-board.5b1157f4b0":"$ core compare --reference scalar","crx-verify-board.0fee9767c8":"optimised vs reference, within contract","crx-verify-board.c25366b7f6":"$ core replay --declared-contract","crx-verify-board.a457a6e5ef":"pure Native, recorded integer sampling, or pure Core on Kera","crx-verify-board.10b035265a":"runnable commands report the selected cell, state, kernel, and replay result","crx-verify-board.a8e712d010":"test it where it will run","crx-verify-board.7894141c57":"the suite connects floor and speed","crx-underfloor.8bbc20b569":"The floor under the products","crx-underfloor.30a882d190":"in place","crx-underfloor.f9e8329057":"never seen, always there","crx-underfloor.0fed3b96cc":"Loom","crx-underfloor.e145a72325":"thinks through problems","crx-underfloor.485a04fef4":"Nexus","crx-underfloor.9259a83ec6":"runs your team of specialists","crx-underfloor.4a86080d67":"Spindle","crx-underfloor.0303aea81b":"protects knowledge","crx-underfloor.a010de5c61":"Fabric","crx-underfloor.895aea3d7e":"where you ask and work","crx-underfloor.6a9007cca7":"Core, the machine under the floorboards","crx-underfloor.c17f52a0b9":"nothing to install, nothing to learn","crx-underfloor.81c11e0852":"you meet the products","crx-underfloor.2d423ede88":"they stand on Core","crx-underfloor.b54c7227ce":"the rooms you open","crx-underfloor.7c9430073a":"the floorboards","crx-underfloor.099a5bf253":"one machine room, shared by every room above","crx-underfloor.0c8645b66f":"feeds every room","crx-workshop-wall.e181598416":"The workshop wall","crx-workshop-wall.fe5f2cef64":"stocked","crx-workshop-wall.ed08a0ec5e":"many tools, one wall","crx-workshop-wall.a9f65113dd":"The one-tool workshop","crx-workshop-wall.58abbe5970":"a tiny screw, a shelf, a steel beam, the same heavy tool for all of them","crx-workshop-wall.efa6e0100a":"The Core wall","crx-workshop-wall.48280468d3":"small + efficient","crx-workshop-wall.d53a4c6252":"precise","crx-workshop-wall.7aca22de0b":"packed","crx-workshop-wall.b55e22fe78":"exact","crx-workshop-wall.fa8405a8c9":"heavy, when needed","crx-workshop-wall.bd6a91639c":"the job picks the tool, not the vendor","crx-workshop-wall.c94b624a6c":"one tool fits nothing well","crx-workshop-wall.723e4cb92a":"the full wall is already inside","crx-workshop-wall.9071079b5e":"each job, its own tool","crx-workshop-wall.fdbee982ab":"a tiny screw","crx-workshop-wall.e90a18ab8a":"a light turn","crx-workshop-wall.46bfd327f8":"a wooden shelf","crx-workshop-wall.5c1e4c9aa6":"a precise cut","crx-workshop-wall.9b70093ac8":"a steel beam","crx-workshop-wall.4ca33f8eaa":"a heavy press","crx-workshop-wall.18a3b9efd8":"the one-tool way","crx-workshop-wall.4722f13348":"one heavy tool forced onto all three","crx-workshop-wall.25caa7595f":"the screw strips","crx-workshop-wall.b2b43725ee":"the shelf splinters","crx-workshop-wall.44f4d67ffe":"the beam barely dents","crx-workshop-wall.84f37afdab":"the same three jobs, forced","crx-ordinary-machines.4824fcada2":"The machines it runs on","crx-ordinary-machines.2a5e9b1b17":"supported","crx-ordinary-machines.f4fe20a4e7":"no special badge required","crx-ordinary-machines.814e1807af":"modern laptop","crx-ordinary-machines.59a5c2ea81":"office computer","crx-ordinary-machines.3de4f901ff":"server","crx-ordinary-machines.465bcea812":"edge device","crx-ordinary-machines.8ab2cea935":"supported work runs here","crx-ordinary-machines.5ecb31bcbd":"larger jobs may still use stronger hardware, by choice","crx-ordinary-machines.06536b2cf7":"no dedicated AI card","crx-ordinary-machines.bd9c4df008":"as the minimum requirement","crx-ordinary-machines.c9997a5fd3":"ordinary machines","crx-ordinary-machines.a0bcfb9bf8":"one task, scaled to the machine","crx-ordinary-machines.89f6229a11":"small","crx-ordinary-machines.5296d5cced":"large","crx-ordinary-machines.b281951d4c":"runs here","crx-stay-close.bac7365554":"The work, staying close","crx-stay-close.88090209e5":"nearby","crx-stay-close.739f0e772a":"distance is a choice","crx-stay-close.e93a19643d":"your device","crx-stay-close.1fe691bda3":"files stay for supported local tasks","crx-stay-close.bda04d342e":"your organisation","crx-stay-close.42449ca364":"processing stays in its own data centre","crx-stay-close.99800d6c30":"regulated places","crx-stay-close.e3989b6664":"the rules of the building still apply","crx-stay-close.0673a9bf59":"the distant data centre","crx-stay-close.3ced461ded":"no longer the default destination","crx-stay-close.6758672fee":"the work stays where you are","crx-stay-close.a019630a1f":"travel becomes the exception","crx-stay-close.f8cb3e6af9":"the work","crx-stay-close.dee5a53ed0":"it stays inside the boundary you already trust","crx-stay-close.5d42ad1769":"exception","crx-stay-close.805468bd44":"sent overseas before it runs","crx-offline-lamp.34069d9998":"The connection drops. The lamp stays on.","crx-offline-lamp.939bb46a04":"local","crx-offline-lamp.9867ffdd1d":"where supported","crx-offline-lamp.dce0f3bb90":"connection: interrupted","crx-offline-lamp.4eeddb9394":"the feature keeps working","crx-offline-lamp.c24129f33e":"the machine and the data are already on the device","crx-offline-lamp.ae3bde3b23":"The other kind of app","crx-offline-lamp.f6eea9abf2":"goes dark the moment the line does","crx-offline-lamp.ab4252b89f":"intelligence brought to the device","crx-offline-lamp.8f619d8e46":"not metered per request","crx-offline-lamp.13fc3116bb":"your Dweve app","crx-offline-lamp.d8cf9a2e8f":"model, on the device","crx-offline-lamp.022c099a05":"data, on the device","crx-offline-lamp.811bf4c4be":"the line is cut","crx-offline-lamp.0384501178":"no signal, no answer","crx-offline-lamp.a78a347759":"still on","crx-light-engine.2d2961b88b":"Two engines, one job","crx-light-engine.38130e342f":"measured","crx-light-engine.ebc5c2452a":"right-sized work","crx-light-engine.a1e8cabbde":"One-size-fits-all","crx-light-engine.e0a1b80e2e":"more memory","crx-light-engine.38541b2f6e":"more electricity","crx-light-engine.3982f98823":"more expensive hardware","crx-light-engine.43da3ecce1":"Core, right-sized","crx-light-engine.17f97379c8":"packs information efficiently","crx-light-engine.15e090416e":"uses the processor's own instructions","crx-light-engine.c3f3559b76":"moves no more data than needed","crx-light-engine.58e8952032":"savings depend on model, task, and hardware; the principle never changes","crx-light-engine.445d0b28e7":"the heaviest calculation","crx-light-engine.04cffe69dd":"is not the default one","crx-light-engine.62af88a20f":"the same job, two routes","crx-light-engine.453042b8a5":"large blocks, sent far","crx-light-engine.2c9c8d2456":"packed data, kept near","crx-light-engine.77f0523215":"remote stack","crx-light-engine.ded6857385":"local processor","crx-light-engine.014eac993e":"more energy","crx-light-engine.15010df884":"less energy","crx-visible-work.26137f28a1":"The work around one answer","crx-visible-work.8204fbd54f":"recorded","crx-visible-work.a156a80810":"supported work","crx-visible-work.a7f6c54e56":"the answer, as you see it","crx-visible-work.88306943fe":"Method","crx-visible-work.5d86f02968":"which model or method was used","crx-visible-work.2eb56be3c2":"Sources","crx-visible-work.6615ada0db":"which inputs were involved","crx-visible-work.bb11a8e3f8":"Rules","crx-visible-work.e052aac3d8":"which constraints shaped the result","crx-visible-work.b76ab65957":"Hardware","crx-visible-work.117bef4e18":"which path did the calculation","crx-visible-work.af2f32cc92":"Decisions","crx-visible-work.f86af7230c":"which recorded steps led here","crx-visible-work.1f90c4429f":"not the model's private thoughts, the visible work around them","crx-visible-work.e45d054ea5":"read the answer","crx-visible-work.3984924ddc":"open the work when you want","crx-visible-work.49d5e6a30a":"answer receipt","crx-visible-work.ee71a35aa3":"on-device classifier","crx-visible-work.772725ab8b":"3 files you added","crx-visible-work.7281b76dae":"EU data rules","crx-visible-work.770be218ef":"laptop, CPU path","crx-visible-work.2ac6771857":"4 recorded steps","crx-visible-work.2a1caa6450":"nothing hidden, nothing invented","crx-visible-work.9873ea8879":"never on the receipt","crx-visible-work.52bc9b1841":"the model's inner workings","crx-visible-work.81addb886a":"your files, sent anywhere","crx-visible-work.3b66d31e86":"a guess dressed up as a reason","crx-visible-work.f7ed6d8d5d":"trust comes from the record, not from a story","crx-repeat-dial.c47fbe25d9":"The same question, asked twice","crx-repeat-dial.3fe6938286":"recorded","crx-repeat-dial.aceaa99ce7":"three guarantees","crx-repeat-dial.803c58703c":"the same request, twice","crx-repeat-dial.df0b6c410f":"Pure Core on Kera","crx-repeat-dial.539199def9":"binary, integer, fixed-point, adaptive and exact work","crx-repeat-dial.50aff7939a":"Seeded Core Native","crx-repeat-dial.4af6f3f372":"floating, bfloat and scale-owning floating work","crx-repeat-dial.41eaab877c":"Pure Core Native","crx-repeat-dial.b01538f80f":"supported floating-family work without a seed","crx-repeat-dial.f4ed4969a5":"creative writing or sampling remains a separate choice when variation is wanted","crx-repeat-dial.145b42d8bf":"the product states the promise","crx-repeat-dial.56f581b5e1":"never accidental","crx-repeat-dial.d7ef49bfc3":"run 1","crx-repeat-dial.fb61066817":"run 2","crx-repeat-dial.6aa7877f19":"output hash 9f2e...c41a","crx-repeat-dial.b283860f0a":"output hash 9f2e...c41a","crx-repeat-dial.27f288e895":"output hash 9f2e...c41a","crx-repeat-dial.d884aafef8":"output hash 9f2e...c41a","crx-repeat-dial.f930bd0484":"seed none","crx-repeat-dial.6df1d0c59a":"seed recorded","crx-dutch-workshop.a92831c31f":"Built in the Netherlands","crx-dutch-workshop.e83249bd3b":"home","crx-dutch-workshop.66b49c2ec1":"the machine and its maker","crx-dutch-workshop.9152c882c5":"designed and built by Dweve in the Netherlands","crx-dutch-workshop.b4197b664a":"Business Workspace","crx-dutch-workshop.96ad0b8f27":"your organisation's infrastructure","crx-dutch-workshop.07c4e0845a":"isolated environments","crx-dutch-workshop.cd65a65706":"not only storing data in Europe, building the technology that performs the work here","crx-dutch-workshop.2537791301":"the machine decides","crx-dutch-workshop.2b2bab257a":"where the work can live","crx-dutch-workshop.fb61c8a8eb":"Netherlands","crx-dutch-workshop.5995fb291a":"three places it can run","crx-dutch-workshop.62e38407fd":"the machine stays inside","crx-hidden-panel.209aa57095":"The panel you never open","crx-hidden-panel.ea88fbaa99":"closed","crx-hidden-panel.579270f535":"complexity, kept inside","crx-hidden-panel.bfa7440fe0":"What you see","crx-hidden-panel.ba5c95340b":"the app opens","crx-hidden-panel.5460b0918d":"the task runs","crx-hidden-panel.4df3046b56":"the answer arrives","crx-hidden-panel.633a84c038":"Behind the closed panel","crx-hidden-panel.f62fc9031c":"numerical format","crx-hidden-panel.5c460825a0":"packing method","crx-hidden-panel.cb68382cdb":"processor instruction","crx-hidden-panel.754a08ddf8":"backend","crx-hidden-panel.4bd05a4d11":"the product makes these decisions according to the task and its rules","crx-hidden-panel.46bf2a3b09":"thousands of operations inside","crx-hidden-panel.b339cccbcb":"zero settings for you","crx-hidden-panel.2bbae26a3d":"three calm steps","crx-hidden-panel.b48f50b04a":"every choice below, made for you","crx-hidden-panel.13566cfb6e":"numerical width","crx-hidden-panel.20329169a8":"accumulator type","crx-hidden-panel.58b67da7de":"dispatch policy","crx-hidden-panel.063e60cccf":"determinism mode","crx-hidden-panel.4898a888c1":"instruction set","crx-hidden-panel.0d612c12d2":"auto","section_st_a2_split-spec-sheet.7c9a7c0610":"Detail","section_st_a6_split-scenario-triad.f75fd3a884":"No runtime deps","section_st_a6_split-scenario-triad.143ac4ef35":"Single binary","section_st_a6_split-scenario-triad.c61f134d87":"Three surfaces","section_st_a6_split-scenario-triad.215475056e":"WHERE IT RUNS","section_st_a6_split-scenario-triad.a794a586f0":"Sealed-room ready","section_st_a6_split-scenario-triad.42d52c32ea":"Local model","section_st_a6_split-scenario-triad.fe6168e59f":"No network","section_st_a6_split-scenario-triad.7d93f83c3e":"Volume-mounted code","section_st_a6_split-scenario-triad.bee0cb05f8":"Kubernetes","section_st_a6_split-scenario-triad.9f1141549f":"Docker","section_st_a6_split-scenario-triad.5315129cfe":"macOS, Linux, Windows","section_st_a6_split-scenario-triad.a89193f674":"No install","section_st_a6_split-scenario-triad.f600b9e709":"One binary","section_st_a7_split-connector-grid.4e6822a6d4":"Hot-reload","section_st_a7_split-connector-grid.19e35f0609":"Set in TOML","section_st_a7_split-connector-grid.d9de50b343":"Caller-driven inventory","section_st_a7_split-connector-grid.8be1bb51b7":"CONNECTORS","section_st_a8_split-scaling-profile.7e0861e04c":"Tunable in TOML","section_st_a8_split-scaling-profile.56d6732417":"Per-project ceiling","section_st_a8_split-scaling-profile.27a454915b":"Active dots reflect concurrent agents per tier.","section_st_a8_split-scaling-profile.0ea215ea0d":"BACKGROUND","section_st_a8_split-scaling-profile.9fc6fb7e03":"TEAMS","section_st_a8_split-scaling-profile.018d2cd1a5":"PARALLEL","section_st_a8_split-scaling-profile.16623c5d4a":"CHAINS","section_st_a8_split-scaling-profile.0fb79c96ed":"Solo → Team → Network","section_st_a8_split-scaling-profile.068f6b3ecc":"TEAM SCALE","section_st_a8_split-scaling-profile.53ebc572b4":"Network","section_st_a8_split-scaling-profile.218887269a":"Team","section_st_a8_split-scaling-profile.9fc93acaa4":"Solo","section_st_a9_split-time-lost-donut.7c9a7c0610":"Detail","section_st_b5_request-lifecycle.47e364232a":"audit #4521","section_st_b5_request-lifecycle.4d3535f846":"patch · session.rs","section_st_b5_request-lifecycle.6c2519cd62":"Tool execution","section_st_b5_request-lifecycle.f6d1c823ab":"session #128 · 14:02","section_st_b5_request-lifecycle.636de0d0c3":"> \"fix this bug\"","section_st_b5_request-lifecycle.0208131a7d":"User request","section_st_b7_audit-chain.9239506454":"0d4e · 8f2c · 51a9 · 73be","section_st_b7_audit-chain.a383df4adb":"a015 · 7c93 · 3e6f · d28b","section_st_b7_audit-chain.efd3faebc5":"9e1b · 22a7 · 8d50 · 6b3c","section_st_b7_audit-chain.4df252b458":"4f2a · b7d1 · 1c83 · e0a4","section_st_b8_defense-stack.eee0f04cba":"YOUR CODEBASE","section_st_b8_defense-stack.89b6e2a784":"DEFENCE IN DEPTH","section_st_c2_dual-loop-flow.9d29573ea6":"tool / step","section_st_c2_dual-loop-flow.08ab1ac55a":"plan / replan","section_st_c5_integration-spoke.55d0677ac3":"All connectors funnel through the same audit + permission layer.","section_st_c5_integration-spoke.c29eb7e425":"Local agent","section_st_c5_integration-spoke.14afd82a7f":"AURA","section_st_c5_integration-spoke.ed0afbab5a":"GitLab CI","section_st_c5_integration-spoke.39540900bb":"GitHub Actions","section_st_c5_integration-spoke.a2feefe9af":"Jenkins","section_st_c5_integration-spoke.ab4115a7b2":"External tools","section_st_c5_integration-spoke.70c123381f":"JSON-RPC 2.0","section_st_c5_integration-spoke.dc99d54d99":"Local","section_st_c5_integration-spoke.6466df1d3d":"Mistral","section_st_c5_integration-spoke.a19ee5a9fd":"OpenAI","section_st_c5_integration-spoke.b780a23b53":"Anthropic","section_st_f1_cta-dark.90e40d5043":"Get started","toc-rail.f5cbdf6bfb":"Contents"}