Skip to content

Roadmap

In order. Without dates.

A date on a roadmap is read as a commitment, and we would be guessing. What we can give you honestly is the order, and which state each piece is genuinely in.

How to read this

Three states, no fourth.

Three states, meaning exactly what they mean in the capability ledger. An item is only live today if there is code to point at.

live today
Runs in production now. Any limits it has are named in its note.
partly built
Something real runs, and it does less than the name suggests. The note says how much less.
in development
Specified and not shipped. Nothing about it works yet, anywhere.

Track 01

Foundations

The parts a context layer needs before any of it is safe to use.

  • Multi-tenant workspaces

    live today

    Every record belongs to a workspace. On the MCP read path the workspace is resolved from the verified credential, never from a tool argument, and a CI guard fails the build if a query in that path loses its workspace filter.

  • Source connections

    live today

    17 source types connect today, each as a scoped grant that can be revoked on its own. Widening what one reads takes a new grant.

  • An MCP endpoint a client can reach

    live today

    JSON-RPC 2.0 over HTTP POST, declaring protocol revision 2025-06-18, authenticated with a per-client bearer credential. Revocation takes effect on the next request.

  • Rate limits

    live today

    Per IP, per credential and per workspace. The cross-instance workspace limiter allows traffic through when its backing store is unreachable, which is a deliberate availability choice and a real limit on the guarantee.

Track 02

Reading your context

A tool asks for what it needs and gets back only that, with the origin attached.

  • describe_workspace

    live today

    Names the workspace a credential reaches, the scopes it holds, the connected sources and how recently each produced anything — and reports the server's own limitations back to the client.

  • search_context

    partly built

    Runs, returns provenance and freshness on every item, and is honest in its own tool description about what it is: a literal case-insensitive substring match, not semantic search. Timestamps are when we received an item, not when it happened at the source.

  • get_context_item

    in development

    Fetch one item with its full provenance chain. Specified in the product definition; not written.

  • synthesize_answer

    in development

    Answer a question across many items with the items cited. Specified; not written.

Track 03

Writing and correcting

Context you state deliberately, amendable without destroying its history.

  • Hand-written context items

    live today

    A decision, preference or project fact, written by a signed-in person with an explicit consent affirmation stored on the item. Creation and deletion both go to the audit log, and no part of the AI pipeline reads the collection they live in.

  • remember_fact over MCP

    in development

    The first permissioned, audited write from a connected client, producing a receipt the user can see. No MCP tool writes anything today, which is what makes implicit capture impossible right now.

  • correct_context and forget_context

    in development

    Amend an item without losing what it used to say, and delete one for real. There is no edit operation at all today — a hand-written item can only be deleted and rewritten.

  • Re-derivation on change

    in development

    Nothing re-derives a hand-written item, so it can be confidently out of date while still being the newest thing in a workspace. Keeping context true as its source changes is the substance of the whole promise, and it is not built.

Track 04

Permission and trust

Who may read which slice, enforced when the request arrives rather than when the data was stored.

  • Per-credential scopes

    partly built

    Two scopes exist and the read scope is enforced on the MCP route. Nothing enforces the ingest scope, and a read credential still sees the entire workspace — separate read, write and export grants are not built.

  • Read-time redaction and source exclusions

    in development

    No redaction rules and no per-source exclusions exist. Until they do, the honest statement is that a credential sees everything in its workspace.

  • Deletion that reaches derived copies

    in development

    A hand-written item deletes for real. Removing everything a connected source produced, including embeddings and cached derivations, is not self-serve and goes through support.

  • Freshness as a visible property

    partly built

    Items carry when we received them, and connected sources report how recently they produced anything. Labelling context as stale, rather than serving it quietly, is not built.

Track 05

Getting in, and getting out

Connecting should take minutes; leaving should not require asking us.

  • Credential onboarding

    live today

    Mint a read-only credential, copy a client config, and run a check that calls describe_workspace against the real endpoint before you trust it.

  • OAuth 2.1 with PKCE

    in development

    Authorization code plus PKCE, metadata discovery, dynamic client registration, refresh and revocation. This is the first item in the build order, because a client that only speaks OAuth cannot connect at all today.

  • Open-format export of everything

    partly built

    Hand-written context exports complete as JSON Lines. The older CSV export of processed records returns the 500 most recent rows and has no provenance column; widening it to cover everything, with provenance, is not done.

  • Prompts advertised over MCP

    in development

    Tools tell a client what it may call; prompts tell it how to ask well. The server advertises tools only.

Deliberately not on it

Four things we are not building.

Leaving something off a roadmap silently is how it gets assumed. These are off on purpose.

  • Loading reusable skills over MCP — plausible later, deliberately not designed yet.

  • Autonomous writes back into the systems you connected. We hold a derived view; the source stays authoritative.

  • Team sharing, roles and per-teammate scoping — out of scope until the loop works for one person across two tools.

  • Mobile clients.

The itemised version of what runs today is the capability ledger, and the docs carry the endpoints and their limits.

Last reviewed 2026-08-12

Early, and honest about it.

Connect a source today, and the parts above marked live are the parts you will be using.