Skip to main content
Scomp is a protocol — plus a reference SDK and runtime — for connecting an LLM agent to a sandboxed execution environment it can drive with code. The agent connects to a scomp port, which exposes a runtime that holds persistent state. The agent submits code; the runtime evaluates it against a set of bindings — application-defined capabilities — and returns the result. Bindings can flow in both directions: the runtime can call the agent’s host, and the host can call the runtime. That’s the entire model. Everything else — agent loops, prompt construction, multi-agent orchestration — lives above the protocol.

​
What scomp does

Negotiates sessions

A client (the agent’s harness) and a server (the runtime host) exchange protocol version, capabilities, and a session id. Sessions outlive connections.

Carries eval and invoke

The client sends code to evaluate. Either peer can invoke the other’s bindings or function references, at any time, bidirectionally.

​
Scomp vs MCP

The two protocols solve adjacent problems. They compose; they don’t compete.

MCP

Exposes individually-callable tools to a stateless agent loop. Each tool call is an isolated round-trip; the agent reasons about which tool to call next from the outside.

Scomp

Projects an agent into a stateful, programmable environment where tool calls compose. The agent writes code that calls bindings, captures results, branches, retries — all inside a single eval.
Both are useful. You can wrap MCP tools as scomp bindings (and vice versa). Picking one over the other is about whether the agent is best served by picking the next tool or by writing a small program.

​
What ships today

Protocol spec

PROTOCOL.md — JSON-RPC 2.0 over any bidirectional transport. Open spec, implementable in any language.

Rust SDK

Client + server, ergonomic macros (#[binding]), QuickJS reference runtime, WebSocket transport. All optional via feature flags.

TypeScript SDK

Planned. Same protocol; the spec is intentionally language-neutral.

​
Where to next

Build something

Quickstart: a server + client in ~5 minutes using the Rust SDK.

Read the model

Concepts: the mental model — peers, bindings, sessions — without any code.

Implement scomp

Protocol overview: what the wire looks like and how to write a conformant implementation.

See examples

Demos: working examples in the repo that show common patterns end-to-end.
Scomp is pre-1.0 and the protocol is at version 0.1. Breaking changes may land at minor-version boundaries until 1.0.