Your agent thinks. Memrail decides.

Deterministically govern tool calls, escalation paths, and multi-step workflows - with full decision traces for debugging and fast iteration.

Built for agents or any intelligent system that proposes consequential actions.

See Adoption Path

Adoption Path

Start observing. Automate when ready.

Three phases from first event to full automation. Each phase delivers standalone value.

Observe Adoption Path Automate
01

Phase 1

Events

Instrument key events for immediate observability and audit trail. No rules required — just structured facts flowing into Memrail.

02

Phase 2

Context

Add state and tags to decision points for richer rule conditions. Your events gain meaning through structured context.

03

Phase 3

Actions

Add rules that execute tools, shape context and trigger workflows. Full automation with safety controls, lifecycle management, and rollback.

Integration Patterns

Three ways to integrate Memrail

Choose the pattern that matches your architecture. All three can coexist in the same system.

First-Class Decision Point

Surface key decision moments in your application as explicit, governed invoke points. Wherever your system asks “what should happen?”, Memrail evaluates context, applies your decision logic, and deterministically resolves the outcome before execution proceeds.

Decision points can live anywhere — inside service layers, workflow steps, background jobs, forecasting pipelines, or agent loops. You elevate consequential decisions into first-class artifacts, instead of leaving them scattered across prompts, conditionals, and hidden logic.

This is the most direct integration pattern: a single invoke call at any point where decisions matter.

First-Class Decision Point: code snippet showing memrail.decide() call alongside flow diagram — Decision Point → Memrail → Prescribed Actions + Trace

Agent Loop Hook

Invoke Memrail inside your agent's reasoning loop — at every step where the system proposes an action. Instead of allowing the agent to execute directly, each proposed tool call, handoff, or state transition is evaluated against your decision logic before execution proceeds.

At every iteration, Memrail receives the current context, deterministically resolves what should happen next, and returns prescribed actions with a full trace. The loop continues — but authority remains explicit and reproducible at each turn.

This pattern gives you fine-grained, step-level control over multi-step autonomous behavior without modifying the model itself.

Agent Loop flow: Agent Step → Memrail Decision → Determined Action → Next Step (loops back)

Event-Driven

Attach Memrail to your event stream and evaluate decisions as state changes occur. When events are emitted — user actions, system signals, model outputs, or data updates — Memrail evaluates the structured context and deterministically resolves the appropriate response.

Rules fire asynchronously based on event patterns, triggering authorized actions, escalations, or workflow transitions. This pattern is ideal for reactive systems where timing, state, and history shape what should happen next.

Authority is not embedded in the event handler — it is resolved explicitly through the decision plane.

Event-Driven flow: Event Source → Memrail Evaluation → Determined Actions → Your Systems (fan-out)

Core Concepts

The building blocks of Memrail

Six concepts that define how Memrail governs autonomous behavior.

Concept
What it is
Decision Point
A place in your code where behavior should be governed. You place an invoke hook here. Every decision point is a location where Memrail evaluates context and returns an authorized action.
ATOMs
Typed facts provided at decision points. Three kinds: state (current values), tags (classifications), and events (timestamped occurrences). ATOMs are the raw material that rules evaluate.
EMUs
Executable Memory Units — rules with explicit triggers, actions, and policies. They fire deterministically when conditions are met. EMUs are the decision logic of your system.
Reachability & Connectivity
Whether a rule's trigger can actually fire (trigger reachability) and whether its action can actually execute (action connectivity). Memrail performs static analysis to prove completeness.
Lifecycle
The promotion path for rules: draftshadowcanaryactive. Each stage adds confidence. Shadow mode observes without executing. Canary runs on a subset of traffic.
Decision Trace
The complete log of a decision: what influenced a decision, what was evaluated, what matched, what was suppressed, what executed, and why. Given the same inputs and rule versions, the trace is identical every time.

Documentation

Full documentation. Request access.

Developer Guide, SDK reference, trigger language specification, API reference, and integration examples — all available with approved access.

Developer Guide v2 Python SDK TypeScript SDK Trigger DSL Reference API Reference Integration Examples

Join the waitlist. We'll notify you as soon as access opens.

Measure impact in 14 days

The 14-Day Decision Authority Pilot: decision topology, domain analysis, controlled comparison, and an integration roadmap on your hardest workflow.

Let's talk