AI Agent Runtime for Coordinated Work | Dweve Nexus

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.

Prose is an anecdote. A trace is evidence a reviewer can accept.

Input, policy, reasoning on one artefact

formed around one task, and it shows its work

The switches are yours. The team is the crew, you are the captain.

Nothing important happens without your say-so.

Your data would travel abroad. Never the default here.

Your information stays in Europe, under European rules.

You could not interrupt. This is never how it works.

Stop the team, look things over, then carry on or stop.

It would step outside your limits. Always kept on.

It works only inside the limits you set.

It would act on its own. You never have to allow this.

It checks with you before anything that matters.

Every cycle runs the same checks and leaves the same trace. Execution is CPU-first and deterministic.

The cycle is the contract: one run, one trace your reviewer can open and replay.

The capability remains recognisable while access, operating responsibility, and contractual rights change.

You operate the licensed estate. Source, modification, and technology-transfer rights follow the selected tier.

Defence, sovereign, and classified environments.

Full functionality in environments that cannot reach the public internet. Update paths, knowledge refresh, and telemetry flow through controlled channels only.

Organisations with strict perimeter rules.

Run Nexus on the infrastructure you already operate. Same product, same governance, but no data leaves your perimeter and no administrative path crosses it.

Workspace policy, users, and usage. Dweve operates the public Mesh and underlying products.

Teams using Nexus capabilities through managed Fabric, its business API, or the Agent SDK.

Nexus capabilities are available through Fabric on the public Dweve Mesh. Managed customers do not operate Nexus itself; Dweve operates the underlying product boundary within the declared European service perimeter.

All stochastic operations use fixed seeds derived from the correlation ID. Sampling, routing jitter, and exploration become deterministic functions of the input.

Agent dispatch, tool calls, and memory updates follow a fixed precedence order. No races, no non-deterministic interleaving. The trace records the exact sequence.

A silent model or policy bump shifts output.

The trace records the exact versions of models, policies, agent definitions, and platform code used. Replay uses the same versions, or flags what changed.

Every decision carries full provenance: the source it came from, the rule applied, and the owner who signed off, captured as the work happens.

When replay produces a different result, the diff engine names the exact layer, operation, and input that diverged. No guessing, no manual bisection.

Same input reproduces the same output, or the diff engine highlights the exact layer that changed.

Governance is the substrate. Every cycle passes the gates, or it stops.

Every verdict is written to the constraint trace.

Within the cycle budget. Breakers armed. A misbehaving step would trip and report.

Statistical detectors saw nothing out of pattern for this kind of decision.

Is this output unusual for this workflow?

Declarative ethics policy evaluated alongside business rules. No violation found.

Does it satisfy the declared ethical policy?

Inbound and outbound text cleared. Personal data redacted before it was acted on.

Any toxic, biased, or personal data to redact?

Payment above threshold. Autonomy is opt-in per action, this one needs a human approver.

Is this action class allowed for this target?

Plan matches the declared intent. No drift between what the step said and what it did.

Does the declared goal match the actual plan?

intent, scope, content, ethics, anomaly, runtime

objective obj-281 · team 5 specialists · cycle 1/1

The runtime for executable organisations · one objective, one formed team, one trace

run decision · hold payment to vendor v-281

sign · M. Bos, ops-3 · 2026-04-12 09:14 CET

account · constraint trace sealed, replayable end to end

text, audio, image, and structured feeds

Independently replaceable, testable, auditable.

Six composable layers feed one cognitive cycle. The cycle emits one constraint trace.

The knowledge graph. Typed entities, inference edges, concepts and relationships.

Learned skills and workflow templates. Successful strategies stored and reused on similar tasks.

Events and outcomes with temporal indexing. A decay curve keeps recent events more accessible.

The active task context, attention-filtered. Pruned automatically when the task shifts.

Consolidation promotes important episodes up to semantic.

Retrieval is not keyword search. It ranks by task context, agent type, and recency, under a token budget.

Structured long-term facts and rules, kept with the source that governs them.

Parallel sub-tasks fork and merge on one trace. The diff engine isolates any divergence.

Circuit breakers, exponential-backoff retry, timeout handling, and fallback strategies declared in the workflow.

Majority voting with thresholds, weighted by expertise, Raft for critical decisions, hierarchical delegation, auction-based allocation.

A genetic algorithm composes the team across 20 to 100 generations. 10 to 50ms for 2 to 5 agents.

Tools and systems reached through an OpenAPI-described interface, contract-first.

Agent-to-agent over JSON-RPC 2.0. Typed request and response, no out-of-band state.

Every task leaves a receipt. Read it, save it, or share it.

pay 84 euro to the gas company. Is that alright?

the bill is normal, paying it is the right call

remembered you pay from the joint account

read your gas bill, found the amount and the due date

A small crew, not a single voice. Each one with a job and a promise.

One voice that only talks. It tells you what to do, then the work is still sitting in front of you. No team, no memory, no receipt.

Pulls out the names, dates, and amounts that matter.

Point a reviewer at one artefact. Input, policy, reasoning, action, outcome, on one trace.

When replay diverges, the diff engine names the exact layer.

Working, episodic, semantic, procedural, knowledge base

one objective, one accountable operation

Bring Nexus an objective that currently crosses people, systems, rules, and approvals. See how the work is decomposed, how the organisation forms, how authority is assigned, how failure is contained, and how every contribution returns to one accountable outcome.

Every contribution returns to the objective

Pipeline, fan-out, delegation, blackboard, debate

Dweve Nexus, the runtime for Executable Organisations

Nexus is a Python multi-agent runtime for work that needs more structure than a prompt loop. Its implementation separates agents, task lifecycle, workflows, memory and capability-based routing into distinct components. Python builders, DweveScript and a CLI define and run that work.

Capability matching, explicit requirements

Use the Python builders, DweveScript or CLI to define agents, tasks and workflows for the work you need to coordinate.

Python builders, DweveScript and the CLI

Working, episodic, semantic, procedural and knowledge

Deductive through hybrid, selected for the task

Dweve Nexus, every task gets its own team

Most AI tools give every job to the same assistant. Nexus works differently. Behind Fabric it forms a team around what you asked, sends each part to the specialist suited to it, and returns one result through the conversation you already opened. You ask once. Nexus organises everything behind it.

Ask once. Let Nexus form the team, divide the work, bring the pieces together, and return one result. The organisation works for you. The authority remains with you.

Typed handovers keep the runtime coherent. Whoever signs for the work reads something else.

The current implementation provides Python builders for agents and a DweveScript compiler for declarative agent and workflow definitions. Its CLI parses, compiles and runs DweveScript files. These are complementary interfaces to the same Python implementation, rather than claims of equivalent Rust, TypeScript or Go clients. A definition written in one of them is the same definition when read from the other, so a team can move between the declarative file and the builder without maintaining two descriptions of the same organisation.

Alongside point to point messages runs a typed event bus, which is what a group of agents actually coordinates on: task requests and results, acceptance and rejection, claims and releases, and lifecycle and health events, with subscribers able to filter, forward, drop and transform what they receive. Two kinds of state are deliberately kept outside individual messages. A blackboard is a declared structure that agents read and write, so a contribution is legible to something other than whoever wrote it.