One agent,
total recall
Every coding session starts from scratch. Your agent re-discovers your stack, your conventions, your decisions — burning tokens on knowledge it already had.
OpRelay stores what your agent learns as structured facts, decisions, and run history. One get_context() call and it knows everything — no more repeating yourself.
// Session 1: Agent learns about your project
await upsert_fact("infra.db.type", { engine: "Postgres 16" })
await upsert_fact("deploy.target", { host: "prod-1" })
await upsert_decision("Use JWT auth — stateless API")
await record_run("Audited stack, documented 12 facts")
// Session 2: Picks up where it left off
const ctx = await get_context("my-project")
// 12 facts loaded, 3 decisions, full run history
// No re-explaining. No "what database do we use?"
Multiple agents,
zero conflicts
Two agents grab the same ticket. Both edit the same file. Merge conflicts, duplicated work, wasted compute.
OpRelay gives your agents a shared task queue with advisory-lock claiming. Facts discovered by one agent are instantly visible to all others. The dashboard shows who is doing what, in real time.
// Agent A: Decomposes the work
await core_create_task("Implement OAuth2 flow", { priority: "high" })
await core_create_task("Add rate limiting")
await core_create_task("Write integration tests")
// Agent B: Claims without conflicts
await core_claim_task(taskId) // advisory lock
await upsert_fact("api.auth", { pattern: "PKCE" })
// Agent A: Sees what B discovered instantly
const ctx = await get_context("my-project")
// B's OAuth discovery is there — build on it, don't redo it
Three pillars. One system.
Everything your agents need to work together effectively, and everything you need to trust what they're doing.
Observability
See what your agents are doing in real time. Runs, failures, facts, usage metrics, and a full dashboard give you complete visibility without reading logs.
Coordination
Deterministic task lifecycle with advisory locks, status transitions, and contention-safe claiming. Multiple agents, one shared truth.
Reconciliation
Stale facts get superseded. Failed patterns get clustered. Agent work flows through a structured pipeline from execution to review to operator sign-off.
Two lanes,
one source of truth
Agents get fast, bounded context optimized for throughput. Operators get legible dashboards with full visibility. Both read from the same Postgres-backed system of record.
No LLM in the data path. Every read and write is deterministic SQL. Append-only audit trail. Project-level isolation.
Up and running in minutes
Self-host with zero-config SQLite, or connect to hosted OpRelay. Either way, your agents have persistent memory in under a minute.
# Self-host in 30 seconds (zero-config SQLite)
git clone https://github.com/oprelay/oprelay.git
cd oprelay/server && npm install && npm run build
npm run dev
# Dashboard at http://localhost:3100
// Connect any MCP-compatible agent
{
"mcpServers": {
"oprelay": {
"type": "streamable-http",
"url": "https://connect.oprelay.ai/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN"
}
}
}
}
Stop re-explaining your codebase
Give your agents the memory and coordination layer they need. Open source. Self-hosted. Works with any MCP-compatible agent.