Senior Systems Developer

About Dweve

Most of today’s AI is built around a simple assumption: bigger models, more compute, and increasingly complex infrastructure are the price of better intelligence.

Dweve started by questioning that assumption.

We are a European AI company building a different kind of AI stack from the systems layer upward. Our work combines neural learning with explicit constraints, deterministic execution, exact provenance and replayable evidence. Instead of treating explainability, efficiency and governance as features added after a model has been built, we design them into the way the system computes.

That has grown into a much broader technology stack than a single model or AI product.

Loom provides our specialist intelligence layer. Core contains the operations and execution substrate beneath it. Spindle handles knowledge, provenance and lineage. Nexus coordinates governed agents and organisations. Mesh distributes execution across infrastructure. Fabric is where people and developers actually work with all of it. Aura focuses on software engineering, while Charter handles the operational side around organisations and partners. Beneath that sits Kera, our systems technology for deterministic execution across different kinds of hardware.

Alongside the commercial stack, we build open foundations that expose many of the lower-level ideas and contracts we work on.

The common thread is simple: AI systems should be understandable, reproducible and practical to run. A developer should be able to know what happened, why it happened, what information was used and whether running it again will produce the same result.

We are still a relatively small team, which makes the work unusually broad. People here are not maintaining one narrow piece of a mature platform. We are building the platform itself, from low-level execution and distributed compute to knowledge systems, agents and developer APIs.

Dweve is based in the Netherlands, and builds primarily for European organisations and infrastructure.

About the role

A lot of what Dweve does eventually comes down to one question: how efficiently can we make the underlying computation run without giving up correctness?

As Systems Engineer, you will work directly on that problem.

You will join the team building Dweve Core, the execution layer underneath much of our stack. That means implementing low-level computation primitives, optimising them for different hardware targets, extending compiler paths and finding the places where a few instructions, a memory access pattern or a different representation can materially change performance.

You will work closely with our Principal Systems Engineer, but this is not a role where you spend your time watching somebody else do the difficult work. You will own real parts of the system and be expected to make them better.

Some days that means writing Rust. Others might involve SIMD intrinsics, GPU kernels, FPGA paths, assembly, compiler internals or staring at a profiler trace until you understand why something that should be fast is not.

There is a lot to learn, and we are fine with that. We care more about strong fundamentals, curiosity and the instinct to measure before guessing than about whether you have already worked on every kind of hardware we support.

What you'll do

• Implement new computation primitives across CPU, GPU and FPGA targets.
• Build and maintain low-level, performance-critical parts of Dweve Core.
• Benchmark implementations properly and understand where the time actually goes.
• Optimise memory access, vectorisation, instruction paths and hardware-specific execution.
• Work on compiler infrastructure targeting multiple execution backends.
• Maintain and extend our library of hardware-optimised algorithms.
• Profile real workloads and turn the results into concrete improvements.
• Work directly with the Principal Systems Engineer on architecture and implementation decisions.
• Own subsystems rather than only contributing isolated parts.