For teams shipping agents
Build agents with Wire
Stop rebuilding the context layer. Wire ships it once. Your users bring their own content. Your agent inherits it on connect.
What every agent team ends up needing
Six pieces, every time
Every agent team builds the same plumbing before they get to build the actual product. Permissioned. Scoped. Sourced from systems of record. Synced as those sources change. Wire is the plumbing, built once, so the team can spend their time on the agent.
Ingest
Get context into a shape your agent can read directly, without converting it inside the context window every session. Wire parses uploaded files, sources, and entries into a queryable graph in the background.
Scope
Separate context per project, per customer, per session, per agent. Each context container is its own scope with its own MCP endpoint and credential. Your agent only ever sees what the task needs.
Permission
Decide which agents and humans can read or write each scope. Wire owns the RBAC and the per-credential tool scoping, so you stop relying on "the source-system permissions still apply" once an agent is in the loop.
Retrieve
Get the right slice back in agent-friendly form, across corpuses too large for any context window. Five standard MCP tools (explore, search, navigate, write, delete) work on every context container from day one.
Sync
When the system of record changes, your agent reads the new version. Wire keeps sources in sync. No versioning logic in the agent, no stale snapshots, no rebuild scripts.
Audit
Every action is logged with the agent identity and the user that authorized it. Ready for the security review that will eventually arrive, by default, with no extra work from you.
Privacy and security
Privacy is a substrate property
Anything an agent reads passes through Wire first. The substrate is built to make that path trustworthy as a property of the system, not as controls your code has to bolt on top.
Isolated
Every context container has its own storage and MCP endpoint. Containers do not share state. Credentials are scoped per container, and a single container can hold multiple scoped credentials for different agents or deployments. None of them escalate to other containers, other users, or org-wide access.
Permissioned
Each context container has its own policies. Credentials are scoped per container, with a per-credential tool allowlist on top. Your agent only ever sees the tools you granted, on the container the credential scopes to. Adding an agent to the loop does not loosen the controls that protect the source data; the scoped credential is the control.
Auditable
Two layers are on the record: credential-side activity (every action an agent takes through a scoped credential) and management-side activity (container creation, sharing, archival, member changes). You see exactly what was done, when, and on whose authority. Compliance evidence, incident response, and customer-facing transparency all come from the same trail.
Need self-deployment, region pinning, or a custom DPA? Talk to us.
Built on the Wire SDK
wire-memory
We built one too. wire-memory is an open-source plugin that gives AI coding agents persistent memory through a Wire context container. Same SDK, same primitives, same path you would take.
An open-source memory plugin for Claude Code, Codex, and Cursor. It gives coding agents persistent memory across sessions through a Wire context container. The connect flow, the storage shape, the retrieval pattern are all the same ones your agent will use. We use it ourselves every day, and the install is three minutes.
How it works
Two primitives, three methods
Context containers hold queryable context. Agents are registered identities that authenticate, operate within a scope, and are attributed in audit. The SDK connects an agent to a container.
Methods
connect opens the consent flow and returns a scoped MCP URL plus an API key for one context container. getStatus reads the live connection. disconnect revokes the credential.
Stateless and portable
The SDK persists nothing; you keep whatever you want from the Connection. Runs on Node 18+, Cloudflare Workers, Deno, and Bun. Light dependencies, Web Crypto under the hood.
// Install
$ npm install @usewire/sdk
// Connect
import { WireClient } from '@usewire/sdk';
const client = new WireClient({ agentId: 'my-agent' });
// Shows a short code, opens the user's browser,
// resolves once they pick a context container.
const connection = await client.connect();
// Hand to your agent's MCP client:
connection.mcpUrl;
connection.apiKey;
connection.containerId;Skip the plumbing
We can walk you through the SDK, the concepts, and the shape of context container ownership that fits your product. Bring a use case and we will sketch it on the call.