AI Compute Stack for Training and Inference | Dweve Core

Choose the audience that matches your question

The page contains three selectable readings of the same subject.

Coding agent and operator assistance. Demo metrics are illustrative.

Terminal, search, lint, test, git, and more.

Remembers your codebase and team context.

Specialised agents collaborate across concerns.

Review diffs, request changes, final sign-off.

Replay any session bit-for-bit when something needs review.

Autonomous agents that write code and keep receipts

to handle network timeouts, 5xx responses, and idempotent-safe conditions. Pure helper, fully unit-tested.

Deployment target, synthesis scaffolding

Runtime dispatcher, picks per call by target and policy

One operator definition, hand tuned kernels per ISA. If your silicon shipped in the last eight years, Core has a path to it.

Capability and determinism stated per cell

Direct operation on customer-controlled infrastructure

the definition and execution slowly disagree

One operator surface across the framework, the engine, and the compiler. No external glue.

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.

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.

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.

Runs on ordinary computers, where supported

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.

What can transfer across the adoption path

one proof path, two licensed operating postures

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.

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.

Built in the Netherlands; operating boundary stated in the agreement

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.

Determinism is a setting, not an aspiration. The test suite asserts it, it is not promised in prose.

dispatch: same integer/fixed model in every mode

core.infer(model, x, determinism="creative", temp=0.8)

Full non determinism where desired. Temperature, top k, and top p sampling. The same dispatch model with determinism relaxed, no separate code path.

core.infer(model, x, determinism="seeded", seed=42)

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.infer(model, x, determinism="hard")

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 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.

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.

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.

You never touch the engine. But everything you feel, the speed, the smoothness, the quiet, comes from how well it was built. Most AI is built from engines bought off the shelf. Dweve built its own, so it runs well on ordinary computers and keeps your things with you.

Core, the quiet engine under every Dweve product

Simple to use, kind to your wallet, and yours to keep

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.

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.

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.

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.

Your letters, photos and questions do not get shipped off to a faraway computer. They stay with you, in Europe, under European rules.

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.

execution cell and replay contract recorded

Core changes the substrate, not the interface you already know.

Hard determinism replays a result bit for bit, on demand.

Compliance is assembled after the hard questions arrive.

EU only data paths, built and run from the Netherlands.

Data lands on a foreign hyperscaler under foreign law.

96% less energy than a GPU stack, the same answers at a fraction of the running cost.

A generative GPU stack draws power by the megawatt.

GPU clusters you bid for against hyperscalers.

Edge and low bit research. Part of the 96% less energy story.

Quantised inference and deterministic fixed point.

Internal training and accuracy-sensitive layers.

Determinism contracts and reference checks.

25 numerical families, no internal FP path

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.

Every internal representation is a first-class citizen, baked into the operator rather than configured after the fact.

The same work, done by one engine you own, instead of a pile of vendor tools glued together.

Five upgrade cycles, five security surfaces, five places it can break.

Every result can be replayed and checked.

Data stays in Europe, on infrastructure you control.

No GPU procurement, no hyperscaler bidding war.

One contract, one support line, one upgrade cycle.

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.

Partial systems create permanent dependence

The definition and the execution slowly disagree.

Compression lives in someone else's tool.

New hardware, new serving system, new behaviour.

The vendor's roadmap becomes your roadmap.

No single system can explain the result.

Dependence persists because the computational space underneath is only partially covered.

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.

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. The 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.

Which path is chosen, under which contract.

The sample is small because the implementation registry is not.

A new width, packing, host, or contract arrives.

The machine picks the path for the new cell.

Which code ran, on which machine, stated.

The first inherited assumption Core removes is that one datatype should dominate everything.

The processor should be just as replaceable as the datatype.

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.