What you can build against today.

Every capability on this page falls into one of three groups. Each group is named in text, so the status never depends on how it is drawn.

Wired today

  • Signed DHCP lease ingestion: HMAC authenticated, replay-windowed, idempotent, and durable before acknowledgement.
  • Two-stage lease processing: a Postgres-only lease stage, then a separate graph stage.
  • The Postgres plus graph split.
  • JWT, API key and operator authentication.
  • Tenant isolation enforced by PostgreSQL row-level security, under a role that cannot bypass it.
  • Subnet allocation over gRPC.
  • DCIM bundle import through an operator CLI.
  • A deploy pipeline with a migration round-trip test and automatic rollback.

In development

  • The REST IPAM API.
  • Agent interfaces.
  • Semantic prefix search.
  • Drift detection.
  • Projection of imported DCIM data into the graph.

Planned

  • Device discovery.
  • Alerting and outbound event fan-out.
  • Vector embeddings.
  • Tenant self-service signup.
  • The Model Context Protocol endpoint.

An intent store and a reality store.

Network infrastructure has two states that differ in shape: intent (what should be true) and reality (what is true right now). Mixing them in one schema creates ambiguity that compounds over time, so OmniTwin keeps them in two stores and lets a Go control plane route each query to the one that fits.

The intent store (Postgres) is the deterministic ledger: CIDR allocations, static reservations, VLAN metadata, ownership and policy, under ACID guarantees.

The reality store (the graph database) holds topology, physical connections and observed state. Index-free adjacency makes multi-hop relationships, such as chassis ports to switches to VLANs to DHCP scopes to DNS records, cheap to traverse, which is what a live interactive canvas and blast-radius analysis need.

When intent and reality diverge, that is drift. Drift detection, and the agents that would act on it, are in development. A what-if preflight check already ships as ordinary code on a tenant route. Semantic search over history is also in development, and it depends on vector embeddings, which are planned.

Postgres 17 Intent store allocations, policy ownership, plans what should be true Graph DB Reality store topology, connections observed state what is true Drift detection compare intent to reality · in development

From a DHCP lease to a DNS record.

This is the one path that runs end to end today. A lease event is verified, made durable, and only then acknowledged. Two separate stages do the work afterwards: the first touches Postgres alone, the second owns the graph. A failure in the graph stage never loses a lease, because the lease is already committed.

A lease event, from Kea to the graph

Seven stages. Acknowledgement happens at stage four, after the commit.

  1. Wired

    A Kea DHCP server posts a signed lease event to the ingestion endpoint.

    • HMAC signed
  2. Wired

    The freshness window is checked first, then the signature, compared in constant time. Every failure returns an identical 401, so a caller learns nothing about which check failed.

  3. Wired

    The event is committed to a durable inbox, idempotent on tenant plus event id. A retried event cannot create a second lease.

    • idempotent on tenant + event id
  4. Wired

    Only after the commit does the endpoint answer. An acknowledgement means the event is durable, so a sender can safely stop retrying.

  5. Wired

    Lease workers claim rows without blocking each other, and never take a row while an older one for the same address is pending. Per-address order holds.

  6. Wired

    The lease is written in one Postgres transaction and the DNS projection is marked dirty. This stage makes no graph call.

    • Postgres only
  7. Wired

    A separate stage claims dirty rows with a fence token, compares desired records against what is projected, and writes the forward and reverse records.

    • fence token
    • forward + reverse

Tenant isolation lives in the database.

This path is wired today. Most multi-tenant systems keep tenants apart because every query remembers a WHERE clause. OmniTwin does not rely on that. The credential decides the tenant, the payload cannot overrule it, and PostgreSQL row-level security enforces the boundary under a role that cannot bypass it. This is what subnet allocation over gRPC passes through on every call.

One request, one tenant

Six stages. The last one is the guarantee: the database refuses cross-tenant rows.

  1. Wired

    Exactly one credential is accepted: an API key, a bearer token, or a JWT. A request carrying more than one is refused.

  2. Wired

    The required scope for the method is checked, and API keys are rate limited.

  3. Wired

    The verified tenant is stamped on the request context. If the payload also names a tenant it must match, because the credential is the authority and never the payload.

  4. Wired

    Identifiers are validated as UUIDs before any SQL runs.

    • UUID check
  5. Wired

    A transaction-scoped advisory lock is taken on the tenant's address space, so two concurrent allocations cannot hand out the same subnet.

    • advisory lock
  6. Wired

    The query runs under row-level security as a role that cannot bypass it, with the tenant set for that transaction. The database enforces isolation, not application code remembering a WHERE clause.

    • RLS
    • tenant set per transaction

DCIM import, and the gap that remains.

An operator can import a DCIM bundle for a tenant through the CLI. The data lands safely in Postgres, under the same isolation rules as everything else. Projection into the graph is not built yet, so imported DCIM data is not visible on the reality side until it is.

Importing a DCIM bundle

Six stages. Five are wired. The sixth is the gap: imported DCIM data does not reach the graph yet.

  1. Wired

    An operator runs the import against a bundle for one tenant.

  2. Wired

    The run refuses to proceed as a database superuser or as any role that bypasses row-level security.

  3. Wired

    It takes a per-tenant lock, so two imports for one tenant cannot interleave.

    • per-tenant lock
  4. Wired

    Per site, it records a run and marks the site as loading.

  5. Wired

    Create-only inserts land in one data transaction. The site is then marked committed, with its projection pending.

    • create-only
    • projection pending
  6. Planned

    Not built yet. Imported DCIM data does not reach the graph today.

The math engine.

10.0.12.0/22 32 bits /22 100120 22 network bits 10 host bits 10.0.12.0/23 510 usable 10.0.14.0/23 510 usable one split, computed once, same answer everywhere

All CIDR arithmetic, subnet splitting, and address-space computation runs in the math engine, a Rust library compiled to the backend. Deterministic results, sub-50ms execution targets, no floating-point ambiguity.

The design constraint is deliberate: the canvas and command bar never perform arithmetic client-side. Every calculation routes through the math engine so that two users looking at the same subnet always see the same answer, regardless of browser or device.

This is both a correctness guarantee and a UX principle. When an agent proposes a subnet split, the numbers it shows are the numbers the engine computed - not a client-side approximation.

"Zero client-side math." The canvas does not do arithmetic. The engine does.

Streaming, not request and response.

The agent interfaces are being designed to stream over gRPC rather than return a single payload. When an agent executes, the UI would receive a stream of typed events: status updates, data chunks, tool calls, and a final result.

The intent is that an engineer sees the agent's reasoning as it happens, including which tool it chose and whether the final action was committed or deferred for approval. No spinner. No black box. None of the agents are wired yet, so treat the envelope on the right as a design sketch.

Design sketch, server streaming envelope
// Stream of typed events, not a single response
[
  status       { "type": "agent_status",    "body": "searching..." }
  data         { "type": "data_chunk",      "body": { "matches": 3 } }
  tool call    { "type": "agent_tool_call", "body": { "fn": "allocate" } }
  commit       { "type": "final_result",    "body": { "committed": true } }
]

Four ways to deploy.

OmniTwin scales from a single engineer's laptop to an air-gapped data center. Each deployment profile is a different infrastructure commitment - same platform, same data model.

Seed

Solo engineer. Single process, SQLite-backed. Local dev or proof-of-concept. One command to start.

Single binary

Team

Small team, cloud-hosted. Postgres + graph database on managed services. The standard deployment for teams up to 50 users.

Managed cloud

Fleet

Enterprise multi-region. Horizontally scaled control plane. Multi-region replication. For networks with 100k+ managed objects.

Roadmap

Iron Vault

Air-gapped, on-premises. Single-binary deployment with no external dependencies. Defense, utility, and regulated-finance environments.

Roadmap

Vendor-agnostic by design.

Agent runtime the stable layer contract · inputs · outputs · tools hosted API swappable local Ollama configured private swappable swap either way, the contract holds

The AI gateway is designed to abstract the model provider entirely. Agents, which are in development, define a contract: inputs, expected outputs, tool bindings. The gateway routes to whichever model is configured, whether that is a hosted API, an Ollama instance on the local network, or a fine-tuned model behind a private endpoint.

The design goal: swap the model, and the agent doesn't change. The data doesn't move. The contract doesn't break.

This is the anti-lock-in argument made concrete. The agent runtime is meant to be the stable layer, with the LLM as a replaceable dependency. When your procurement team asks whether you're locked into a specific AI vendor, the answer is no - by architecture, not by promise.

Edge and core.

Edge · per-record state ip record durable object device durable object session durable object agent protocol Core Go control plane · Rust math · both stores edge answers fast, core does the heavy lifting

Edge: Cloudflare Workers + Durable Objects. Core: Go + Rust + Postgres + graph database. Agents are planned to run at the edge and talk to the core over an agent protocol, which is not wired yet.

The Cloudflare layer handles the agent runtime and real-time coordination - each IP record, each device object is a Durable Object with persistent state and low-latency access. The core backend handles the heavy lifting: CIDR math in Rust, control-plane logic in Go, persistent storage across both databases.

How a change reaches production.

This path is wired today. If you build against OmniTwin, you should know how the backend ships. Merging does not deploy. Every change passes a migration round trip, a human dispatches the deploy, and the pipeline verifies the schema and the database grants before it cuts over. A failed step rolls back on its own.

From pull request to healthy production

Seven stages. Deployment is a deliberate choice, and rollback is automatic.

  1. Wired

    A pull request to main must pass the required checks.

  2. Wired

    They include a migration round-trip test, which applies a migration, reverses it, and reapplies it, and a foreign-key gate.

    • migration round trip
    • foreign-key gate
  3. Wired

    A container image is built and pushed.

  4. Wired

    Deployment is a deliberate manual dispatch, not automatic on merge.

    • manual
  5. Wired

    Migrations run, then schema fingerprints are checked.

  6. Wired

    Application role grants are applied and verified. The deploy stops if verification fails.

  7. Wired

    Traffic cuts over, then health is polled before the deploy is called good. A failed step triggers automatic rollback.

    • health polled
    • automatic rollback

Get early access.

We're onboarding the first teams now. Join the list and we'll reach out when your slot opens.

No spam. No sales calls. By submitting you agree to our Terms and Privacy Policy.