Your pipeline builds the output.
Flow gates decide if it's safe to act on.
LangGraph, CrewAI, and AutoGen handle orchestration. Rynko Flow handles the question your pipeline can't answer on its own: is this output correct, compliant, and safe to deliver? Each gate you configure appears as an MCP tool — auto-discovered, description-first, no hardcoded IDs.
Each gate is an MCP tool
Create a gate in the dashboard — it immediately appears as a tool in your next MCP session. No code changes, no redeploy.
Configure a gate
Give it a name, description, JSON schema, and business rules. Optionally set an approval condition for human review.
Connect your orchestrator
Point your agent framework at the Flow MCP SSE endpoint. On connect, tools/list returns one tool per gate in the environment.
LLM picks the right gate
The gate's description is the tool's description. The LLM selects the correct gate from context and submits the payload.
Gate configuration
MCP tool exposed to agent
Built for production pipelines
Not just schema validation. The features that matter when AI runs at scale.
Add or update a gate in the dashboard — it appears automatically in the next MCP session. No code changes, no redeployment.
Set a condition (e.g. amount > 20000) to route runs to a human reviewer via magic link. Reviewers need no Rynko account.
Consecutive failures trip the circuit breaker. The server pushes a real-time pause notification through the persistent SSE session — stopping the agent before it wastes further runs.
Framework integration
Connect your orchestrator to the Flow MCP SSE endpoint. Gate tools are discovered automatically — the LLM picks the right one from context.
langchain-mcp-adapters pulls gate tools from the Flow endpoint. Wrap them in a ReAct agent inside your graph — LangGraph handles state and routing, Flow handles validation.import asyncio
import os
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic
# Each gate you've configured is a distinct MCP tool.
# Gate name + description = tool name + description.
# The LLM picks the right gate from context — no hardcoded IDs.
model = ChatAnthropic(model="claude-opus-4-6")
async def run_pipeline(prompt: str):
async with MultiServerMCPClient(
{
"rynko-flow": {
"url": "https://api.rynko.dev/api/flow/mcp",
"transport": "sse",
"headers": {"Authorization": f"Bearer {os.environ['RYNKO_API_KEY']}"},
}
}
) as client:
# tools/list is called on connect — one tool per gate in your environment
tools = client.get_tools()
agent = create_react_agent(model, tools)
# LangGraph handles routing; the agent uses gate tools to validate
# Circuit breaker trips arrive as SSE notifications through this session
result = await agent.ainvoke({"messages": [("user", prompt)]})
return result["messages"][-1].content
asyncio.run(run_pipeline(
"Validate this invoice: vendor=Acme Corp, amount=25000, currency=USD."
))Gate run outcomes
validatedAll schema checks and expression rules passed. Proceed with downstream action.
validation_failedOne or more rules failed. Response includes error.details[] with field-level messages.
pending_approvalApproval condition met — routed to a human reviewer. Poll for decision or use webhooks.
Escalate to a human when it matters
Not every run needs a human. Set a condition expression on any gate — runs that match go to a reviewer, everything else auto-completes.
Set an approval condition on the gate
Expression syntax uses the payload fields directly. Examples: amount > 20000, risk_score >= 0.8, country not in approved_list.
approvalCondition: "amount > 20000"Run is routed to a reviewer
When the condition is true, the run enters pending_approval. Reviewers receive a magic link — no Rynko account required.
status: "pending_approval"Pipeline receives the decision
Approval or rejection is delivered via webhook or polling. The pipeline resumes with the reviewer's decision and any notes attached.
status: "approved" | "rejected"Most validation is deterministic — schema, ranges, business rules. Automate those.
But some decisions need judgment: a high-value contract, an unusual risk flag, an edge case the rules didn't anticipate. That's where human review adds real value.
Flow lets you express exactly where that threshold is, per gate, without changing your pipeline code.
Reviewer experience
Magic link access — reviewers see the full payload, validation results, and rule details. One click to approve or reject, with an optional note back to the pipeline.
Stop runaway pipelines before they spiral
When a gate sees too many consecutive failures, it trips. The server pushes a real-time notification through the persistent SSE session — the agent knows immediately, before submitting another run.
Why SSE makes this possible
The MCP session is a persistent SSE connection. The server can push events to the client at any time — not just in response to a request. A tripped circuit breaker is one of those events.
What happens when it trips
The gate is automatically paused. The agent receives a notification and stops submitting runs. An alert appears in your dashboard. You can inspect the failures and resume the gate manually.
Why stateless HTTP can't do this
With plain HTTP calls, there's no channel for the server to push unsolicited events. The agent would keep submitting runs, keep getting failures, and never know the gate had been paused until it checked manually.
SSE event — circuit tripped
The agent receives this through the open SSE connection and halts further submissions to this gate.
Add validation to your pipeline today
Configure a gate, point your agent framework at the Flow MCP endpoint, and your first gate tool is live in minutes.