Skip to content

The runtime for agents that do real work.

tectic runs agents as durable graphs on European infrastructure. Steps checkpoint, irreversible actions wait for a human, and every run ends with a record of what happened.

Products

5 products run on it.

Each one is a real product with real users, built on the same runtime. That is how the platform gets found out before customers do.

GRID

Describe a deliverable in your own words. GRID asks the questions that matter, shows the cost before it starts, works in the background, and brings back the finished result.

About GRID ->

Plietsch

Connect an authorised inbox or share your documents. Plietsch builds a source-backed picture of your people, teams and stakeholders, where every fact links back to where it came from.

About Plietsch ->

KIRA

Local public information, made readable. KIRA reads a council's own information system and turns what happens there into content a resident can follow.

About KIRA ->

SSI

Strategic signal intelligence for political and policy work: what moved, who moved it, and what it means for the position you hold.

About SSI ->

makerie

Automate a brand's creative production lifecycle. Specialised roles run as stages of one pipeline, each with its own guardrails and audit trail.

About makerie ->

The runtime

What every product above inherits.

Durable execution

Agents run as graphs, not chat loops. Every step checkpoints, so a run survives a restart and resumes where it stopped.

Approval as a step

An approval gate is a node in the graph, not a callback bolted on the side. The run suspends until the person who owns the decision answers.

Receipts

Every run ends with a record: the graph version, the inputs and their hashes, the models called, each approval, and the result.

Connectors

One place to authenticate the tools the work already lives in. Tokens are isolated per tenant and never reach a prompt.

Sovereignty

European by construction, not by configuration.

Inference runs on European infrastructure. The data layer is ours rather than rented. There is no US model API anywhere in the codebase, and the build fails if one appears, which makes it a property of the software rather than a promise on a page.

  1. 01

    Core engine public

    takeln under Apache-2.0.

  2. 02

    Build rule

    The build fails on a non-European model call.

  3. 03

    Per-tenant isolation

    Its own namespace and its own execution boundary.

  4. 04

    Paperwork

    DPA, processor list and a deletion path.

The stack

Five parts, end to end.

Most of what an agent platform needs, we build rather than rent — which is why the sovereignty claim above is checkable rather than contractual. The parts we build are Rust, and named in Plattdeutsch because the whole thing was built in Hamburg.

takeln

Orchestration

The graph engine every agent runs on. Checkpoint-resume so a run survives a restart, loops and dynamic orchestration, typed approval gates, and a failure policy per step rather than one blanket retry. Apache-2.0, usable without the rest of this list.

Apache-2.0 on GitHub ->

reede

Trust

The layer that makes a run accountable: the signed receipt, the tenant isolation boundary, the budget ledger a run spends against, and the control plane and SDKs that drive all of it.

weeger

Feedback

Ratings, the edits a human made before sending, and outcomes that only arrive weeks later — all joined back to the run that produced them, so an agent's behaviour can be argued about from evidence.

upcloud

Infrastructure

European infrastructure, in European datacentres, under European ownership. Every run executes here; nothing crosses to a US region for convenience.

cortecs

Inference

European model inference. Models are swappable by design, and there is no US model API anywhere in the codebase — the build fails if one appears.

Hosted in the EU

Compute, data and inference stay inside European infrastructure.

Built for the GDPR

Per-tenant isolation, a DPA and a processor list, and a deletion path that actually deletes. Nothing you run trains a model.

Open source

The engine is public.

takeln is the graph engine underneath everything here: checkpoint-resume, loops, dynamic orchestration, typed approval gates, per-step failure policy. Apache-2.0, usable on its own, no stripped-down demo edition.

FAQ

Questions we get asked.

Where does the work run?

On European infrastructure, end to end, including inference. The data layer is self-hosted rather than rented, isolated per tenant. Nothing you run is used to train a model.

Which models do you use?

Whichever European-hosted model fits the step. Models are swappable by design; the runtime, the approvals and the record are the parts that stay.

Can an agent act without asking me?

Only where you allow it. Irreversible steps sit behind approval gates in the graph itself.

Is it open source?

The graph engine is, under Apache-2.0. The trust layer, connectors and products are commercial.

Who builds this?

NMA, a venture studio in Hamburg.