Roadmap

Everything we have shipped, and what comes next.

24 capabilities are running in production today and 32 more are committed. Every item below is real work on a real backlog, not a wish list. Dated horizons are our intent, and we would rather you hold us to a date than read a roadmap with none.

Last reviewed against the platform on 25 July 2026.

Available now24In beta3Q3 20267Q4 202610202712

Capability matrix by tier Changelog

Available now

Running in production today · 24 items

Infrastructure and networking

Where your AI runs, and how those machines reach each other.

Private node orchestration

Provision a node as a shared pod, a private pod, or dedicated EC2, and the control plane handles its lifecycle from there.

One runtime on every path

The same Node Runtime serves your node whether it runs on Kubernetes, on a dedicated instance, or on your own laptop.

Encrypted mesh

Nodes reach each other over WireGuard on your own tailnet. Nothing about a node is exposed to the public internet.

Bring your own network

Attach nodes to a network you already run, rather than accepting one we chose for you.

Region pinning at provisioning

Choose where a dedicated node is created, and it stays there.

Knowledge and retrieval

Turning your documents into answers you can check.

Document ingestion

PDF, DOCX, plain text, and URLs, parsed and chunked into your knowledge base.

Knowledge base on your node

Your corpus and its vectors live in a pgvector store on the node you control, not in a shared index.

Hybrid search

Vector similarity and keyword matching run together and fuse their rankings. A question finds the passage whether it shares the wording or only the meaning.

Cross-encoder rerank

A second pass reads each candidate passage against the actual question and reorders on what it finds.

Citations that open their source

Every claim carries the document, page, and passage behind it, and clicking one opens the text the answer drew on.

Ingestion status and per-document stats

Each document reports whether it is embedding, ready, or failed, and a failed one says why instead of sitting in the list looking finished.

Inference

The model itself, and where the thinking happens.

In-pod generation

Paid tiers run the model on their own node, so a question and its context never leave the boundary to be answered.

Bring your own local models

Point a local node at Ollama, LM Studio, vLLM, or llama-server and run against a model you already have.

Per-tenant inference identity

Each tenant calls out under its own cloud identity, so usage and access are attributable to that tenant alone.

Console, CLI, and API

The ways you drive it: a browser, a terminal, or your own code.

Knaix CLI

Sign in, provision and manage nodes, or run a node on your own machine with no account at all. Open source, Apache-2.0, on macOS, Linux and Windows.

knaix doctor and knaix bench

Diagnose a node that is misbehaving, and measure what yours actually delivers.

Node console with addressable surfaces

Overview, knowledge, chat, metrics, usage, logs, and settings each have their own URL, so any of them can be bookmarked or sent to a teammate.

Infrastructure observability

Live metrics and logs for each node, read from the node itself.

Chat history

Threads persist, resume where you left them, and delete for real. Transcripts follow the same residency rule as your documents.

Security and governance

Proving that what we claim about your data is actually true.

Signed releases you can check yourself

Every release is signed by the workflow that built it, so there is no signing key to steal. knaix verify checks the binary you are running: its checksum, its signature, and how it was built.

Node residency

Your knowledge base and chat history sit on your node rather than in our database. Residency by architecture, not by policy.

Node-side query pipeline

Retrieval, reranking, and prompt framing all run on your node, so the control plane never handles the passages your answer is built from.

Zero-trust auth

Every call between the control plane and a node is authenticated and scoped, with no implicit trust from being inside the network.

Immutable audit log

Control-plane events are append-only and hash-chained, so the record cannot be edited after the fact, including by us.

In beta

Working, under active development · 3 items

Mesh (agent to agent)

Several of your machines working on one question together.

Peer discovery and routing

Nodes in your mesh find each other and route work between themselves without going through a central broker.

Map-reduce synthesis

A question that spans several nodes is answered in parallel on each, then combined into one grounded answer.

Mesh telemetry

See which nodes talked to which, when, and for what. Currently an operator view.

Q3 2026

In progress this quarter · 7 items

Infrastructure and networking

Where your AI runs, and how those machines reach each other.

Automated node snapshots

Daily encrypted snapshots of a node, with one-click restore and migration between sizes.

Mesh (agent to agent)

Several of your machines working on one question together.

Brokered synthesis as the default path

Cross-node synthesis runs on the peer that holds the data, so a mesh answer needs no central compute at all.

Console, CLI, and API

The ways you drive it: a browser, a terminal, or your own code.

Team accounts and roles

An organization with members and role bindings, so access is granted to a person rather than shared through one login.

Mesh telemetry for your team

The operator view of node-to-node activity, promoted into the customer console.

Security and governance

Proving that what we claim about your data is actually true.

Audit log in the console

Read and export your own audit trail rather than asking us for it.

SSO with SAML and OIDC

Mesh activity in the audit log

Agent-to-agent interactions recorded in the same tamper-evident trail as everything else.

Q4 2026

Committed, next up · 10 items

Infrastructure and networking

Where your AI runs, and how those machines reach each other.

Node health alerting

Find out that a node is unhealthy from a notification rather than from a failed question.

Knowledge and retrieval

Turning your documents into answers you can check.

Scheduled ingestion and re-index

Point a node at a source once and keep it current, with refresh and re-index under your control.

Inference

The model itself, and where the thinking happens.

Agent profiles

A named agent with its own prompt, its own slice of your documents, and its own model, instead of one assistant per node.

Tool-calling engine

Agents that execute structured functions in-pod and reach systems inside your VPC, the first phase of the agent runtime.

Console, CLI, and API

The ways you drive it: a browser, a terminal, or your own code.

OpenAI-compatible endpoint

Point an existing client at your node by changing a base URL. No rewrite, no SDK swap.

MCP server on your node

Your knowledge base exposed as tools and resources, so any MCP client can query it under your boundary.

Public API reference

A published OpenAPI spec for the control plane and the Node Runtime, so integrating does not require reading our source.

One-command data exit

knaix export takes everything out, in a format you can read without us. Leaving should be as easy as arriving.

Security and governance

Proving that what we claim about your data is actually true.

Document-level access control

Decide which people and which agents can see which documents inside one tenant.

SIEM export

Stream audit events into Splunk, Sentinel, or an S3 bucket on your side.

2027

Planned, not yet scheduled · 12 items

Infrastructure and networking

Where your AI runs, and how those machines reach each other.

Public status page

Platform availability you can check without asking us.

Knowledge and retrieval

Turning your documents into answers you can check.

Long-term agent memory

Memory that consolidates over time instead of resetting each session, held in your own store.

Answer-quality evaluation

Measure how well your own corpus answers your own questions, on your own node.

Mesh (agent to agent)

Several of your machines working on one question together.

Multi-agent collaboration

Agents delegating subtasks to each other across your mesh.

Inference

The model itself, and where the thinking happens.

Deploy your fleet

Purpose-specific models deployed across your nodes, with specialist routing and a general-purpose fallback.

Workflow pipelines

Declarative multi-step workflows, versioned in your own repository.

Console, CLI, and API

The ways you drive it: a browser, a terminal, or your own code.

Spend and quota visibility

What inference is costing, per node and per agent, before the invoice.

Agent starter templates

Preconfigured agents for common jobs, so a new node is useful before you have designed a prompt.

Security and governance

Proving that what we claim about your data is actually true.

Regional data residency and compliance profiles

A governed profile attesting to the jurisdiction a node runs in, beyond the region pin that ships today.

SOC 2 Type I

Scoped, with a timeline, for buyers whose procurement needs the report and not the argument.

Trust center

The security whitepaper, subprocessor list, and questionnaire pack in one place, rather than on request.

Owner-held mesh identity

Mesh keys held by you and delegated as scoped capability tokens, so joining a mesh never requires us to hold the key.

Something missing that you need?

Private beta customers shape what lands next. Tell us what your deployment requires and we will tell you honestly whether it is on this page, or why it is not.

Request private beta