Agent Execution Runtime

Scoped permissions, enforced policies, and unified payment rails for Ethereum agents.

ExecutionContext, policy engine at the tool layer, and a unified x402 + MPP payment rail — packaged as a TypeScript SDK.

Get Started

Integrated with

How it works

The execution infrastructure agents are missing.

Structured intent routing, policy enforcement at the call layer, and unified payment rails — so agents can act safely and verifiably on Ethereum.

// Payment Rails

Unified x402 + MPP payment abstraction

One SDK primitive abstracts x402 crypto micropayments, MPP web2 rails, and onchain gas. The runtime selects the right rail per action transparently — no manual wiring.

Stylized digital payment card formed from glowing data streams, representing agent transactions and card spend.

// Policy Engine

Enforcement at the tool layer, not spawn time

OPA-style rules evaluated at every tool call. Actions are risk-tiered — LOW auto-executes, CRITICAL requires passkey sign. Prompt injection can't bypass it because the constraint lives in the execution layer.

Abstract visualization of teams in VR headsets formed from code, representing enforced spend policies and guardrails.

// Intent Taxonomy

Deterministic routing across 20+ intent classes

A structured schema of Ethereum retail intents — from simple swaps to multi-agent LP rebalancing — each mapped to params, protocol templates, risk tier, and payment rails. No hallucinated tool calls.

Leaders gathered around a glowing data surface, illustrating hierarchical agent delegation and collaboration.
Lifecycle

From intent to on-chain execution.

Every agent action flows through intent classification, scoped context, policy enforcement, and verified execution — in that order.

  1. 1

    Classify intent

    User intent is parsed into a structured class — swap, liquidity, send, rebalance — with extracted params, risk tier, and protocol rails.

  2. 2

    Scoped execution context

    Each agent run gets a passkey-bound, TTL-limited ExecutionContext. Sub-agents can only narrow scope — never expand it.

  3. 3

    Policy check at the tool layer

    Every tool call is evaluated against OPA rules before execution. HIGH and CRITICAL actions require explicit confirmation or passkey sign.

  4. 4

    Execute and verify

    Action routes through the correct protocol template. Every step is signed, logged, and anchored on-chain.

Diagram of the Rhemify stack: you at the top, the Rhemify platform in the center, branching to agents and services with connected capability tiles.
Built for you

However you build

Ship agents that execute on Ethereum — safely, out of the box.

The SDK handles scoped contexts, policy enforcement, and payment rails. You define the intents and risk tiers. Agents do the rest with guardrails built in.

Plans made for every agent fleet

Start with a free CEO agent and two departments. Scale to unlimited agents with full spend policies when you're ready.

Free

$0 /month

Kick the tires with a single CEO agent and two departments.

Get Started
  • CEO agent always included
  • 2 department agents
  • Real-time transaction feed
  • Basic spend guardrails
  • Community support

Pro

$9 /agent /month

For teams running production agent fleets with full delegation.

Get Started
Everything in Free, plus:
  • Unlimited agents & departments
  • Per-agent spend policies
  • Multi-chain payments
  • Approved vendors & daily limits
  • Agent-to-agent delegation
  • SDK access
  • Real-time audit logs
  • Auto-freeze on policy breach
  • Priority support
  • Only active agents are billed
Illustration representing open, verifiable agent payments and treasury control.

Partner with us

Build agents that act on Ethereum — with verifiable execution and unified payment rails.

Start with RhemifyTalk to our team