Reactivity Primitive

Memory that reacts.
In real time.

Webhooks, WebSocket streams, and an inbound inbox — all built in. Subscribe to every memory write, every dream cycle, every insight. <250ms delivery. No polling. No glue code.

Get Your API Key Read the docs

Event types

Four event streams. Everything observable.

Every state change in your knowledge substrate is an event. Subscribe to what matters, filter what doesn't, route to wherever your stack needs it.

memory.*

Writes, updates, deletes, merges. Every memory operation fires an event with full before/after state.

dream.*

Cycle start, strategy step, insight proposal, tournament winner. Full Dream Engine transparency.

insight.*

Generated, accepted, rejected. Turn your review decisions into training signal for other systems.

channel.*

Publish, subscribe, A2A peer message. Multi-agent federation events without building pub/sub yourself.

Three delivery modes

Push, stream, or inbox — your call.

REM supports the three canonical reactivity patterns. Pick one, combine any, or use all three for redundancy.

# 1. Outbound webhook — REM calls you
POST /v1/webhooks/register
{
  "url": "https://myapp.com/hooks/rem",
  "events": ["memory.write", "dream.insight"],
  "secret": "whsec_..."   # HMAC-SHA256 signed
}

# 2. WebSocket stream — you hold the socket, REM pushes
const ws = new WebSocket("wss://slopshop.gg/v1/stream?topics=memory,dream");
ws.onmessage = (e) => handle(JSON.parse(e.data));

# 3. Inbound inbox — your agent posts to REM
POST /v1/inbox/:namespace
{
  "from": "research-agent",
  "kind": "finding",
  "payload": { ... }
}
    

Reliability

Production-grade delivery.

What you'd build yourself — without building it yourself.

<250ms

p95 delivery

Global edge fanout

Retry policy

Exp. backoff, 1m→1h

HMAC

Signed payloads

SHA-256, replay-safe

30d

Delivery log

Every attempt, queryable

Dead-letter queue catches what can't be delivered. Replay from the log with one API call. Rate limits are per-webhook, not per-account.

Patterns

What teams build with reactivity.

Slack ops

Dream insights land in #product-intel the moment they're generated. Team reviews async, accepts from Slack.

Linear automation

@Decision primitives auto-create Linear issues tagged with the originating context. No copy-paste.

Multi-agent coordination

Research-agent publishes to a channel; planning-agent subscribes. Knowledge federates without shared memory.

Stop polling. Start reacting.

Every webhook, every stream, every event type — included on the free tier. Build reactive knowledge infrastructure in an afternoon.