Safely coordinate AI agents from idea to execution.
Give Ruligent an idea, a repository, or an existing business. Specialized agents analyze, validate, plan, and prepare execution — while every action stays behind your policies, spend limits, human approvals, and a complete audit trail. Built on the same guard API that protects any agent's tool calls.
Free plan, no credit card. Private deployment options are available for qualified teams.
// Your agent, one call before it acts: await ruligent.guard({ agentId: 'finance-agent', tool: 'wire_transfer', estimatedCostUsd: 1200 }); // Ruligent's decision — explained, logged, auditable: { "decision": "require_approval", "allowed": false, "reason": "Rule \"Require approval for payments and transfers\" requires human approval", "riskLevel": "critical", "approvalId": "apr_8c21…", "eventId": "evt_f04a…" }
Agents act. Someone has to answer for it.
AI agents send emails, call APIs, move money, and change data. Without a control layer, one bad tool call becomes an incident — and nobody can reconstruct what happened.
Unbounded actions
An agent with a payments tool can spend real money. One with an email tool can contact your entire customer list. Nothing stops the marginal bad call.
No audit trail
When something goes wrong, "what did the agent do, when, and why?" has no answer. Compliance and customer-trust conversations stall without evidence.
Runaway spend
Loops, retries, and tool misuse turn into surprise bills. Spend controls in each provider's console don't cover what your agents do across systems.
One gate in front of every agent action
Ruligent sits between your agent and its tools. Every risky call is checked against your policies first — and every decision is logged, explained, and attributable.
Explainable decisions
Every guard check returns a structured decision with the reason, matched rule, risk level, and an audit event ID. No black boxes — you can always answer "why was this allowed?"
Strict precedence, fail-closed options
Kill switches beat everything, then spend limits, then policy rules by priority, then your org default. Flip your default to block and unknown actions never run.
Guarded in three steps
Add one call before your agent acts
Drop in the TypeScript or Python SDK — or wrap any MCP server with the Ruligent MCP gateway, no code changes to the server at all.
Set your policies
Install the recommended safety pack in one click, or write rules that match agents, tools, and actions by pattern — with cost floors, rate limits, and risk levels.
Approve, audit, and control
Risky calls wait for a human in the approval queue. Every decision lands in the audit log. If anything looks wrong, hit the kill switch — org-wide, per agent, or per tool.
Venture Mode
Seven specialized agents take a project from idea to launch preparation — analysis, validation reports, PRDs, roadmaps, read-only repo analysis, brand and launch drafts, and launch-readiness scoring. Every agent task is routed through the same guard pipeline as any other agent action: it's a guarded, audited event with a decision you can inspect. You approve; you own the outcomes.
Validation Agent
Determines whether an idea is worth pursuing — and says so honestly, including STOP.
Product Agent
Turns direction into PRDs, roadmaps, stories, and success metrics.
Engineering Agent
Analyzes the repository (read-only) and proposes implementation plans. Never pushes code.
Design Agent
UX recommendations, flows, page requirements, and brand and copy improvements.
Launch Agent
Launch-readiness scoring, checklists, positioning, and draft launch assets.
Growth Agent
Experiments, content ideas, and funnel analysis — every idea tied to a testable assumption.
Operations Agent
Watches tasks, risks, and recurring work; suggests improvements. Risky actions always go to approval.
Not autopilot
Agents draft, analyze, and execute only approved workflows. Venture Mode does not run your business for you, and no outcome is guaranteed.
Autonomy you dial in per project — with a hard floor
Level 0 only suggests; level 1 executes when you click Run; level 2 auto-runs reversible analysis and draft tasks; level 3 runs approved workflows end to end; level 4 executes within strict policies. Regardless of level, four categories always require a human approval: external communication, spending money, deleting or overwriting data, and production deploys. That floor cannot be configured away.
The control plane for agent actions
Policy engine
Priority-ordered allow / block / require-approval rules with glob matching on agent, tool, and action, cost floors, and per-rule rate limits. Deterministic and fully tested.
Human approvals
Approval requests with expiry, reviewer identity, and notes. Approve from the dashboard or the API; agents can wait for the verdict before acting.
Audit logs
Append-only decision events with actor, tool, decision, reason, risk, and cost — filterable, exportable to CSV/JSON, and linked to approvals.
Spend limits
Daily and monthly USD caps per organization, per agent, or per tool. Projected overspend is denied before the money moves.
Kill switches
Instantly refuse all calls org-wide, for one agent, or for one tool. The kill switch outranks every other rule — including allows.
Signed webhooks
Every decision, approval, and kill-switch change can notify your systems — signed with HMAC-SHA256 so you can verify authenticity.
Use the guard API from any stack
The REST API works from TypeScript, Python, OpenAI, Anthropic, LangChain, CrewAI, the Vercel AI SDK, n8n, and anything else that can make an HTTP request. Ruligent package publication remains intentionally gated until namespace ownership is verified.
TypeScript / JavaScript
const response = await fetch('/v1/guard', { method: 'POST', headers: { 'Authorization': `Bearer ${process.env.RULIGENT_API_KEY}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ agentId: 'sales-agent-01', tool: 'send_email', payload: { to: 'customer@example.com' }, }), }); const decision = await response.json();
Python
import os, requests response = requests.post( "https://agentgate-one.vercel.app/v1/guard", headers={"Authorization": f"Bearer {os.environ['RULIGENT_API_KEY']}"}, json={ "agentId": "sales-agent-01", "tool": "send_email", "payload": {"to": "customer@example.com"}, }, ) decision = response.json()
Framework integrations without package-name risk
Wrap the tools of the stack you already use so every tool call routes through the same policies, approvals, spend limits, and audit trail. Bring your own HTTP client today; package distribution will be enabled only after the Ruligent namespace is verified. See the documentation for framework integration guidance.
MCP gateway: guard tools you don't own
The repository includes a privately deployed MCP gateway that can sit between an MCP client and server. Blocked calls return a tool error and the downstream server is never invoked; guard failures deny the call by default. Follow the MCP gateway guide for the current compatibility-safe command.
The trust layer for the agent economy
Today, Ruligent governs the agents you run. The registry underneath it — agents, tools, risk levels, policies, usage — is built to become the trust fabric between agent builders and agent buyers: discover a capability, see its risk profile, bind it to your policies, and monitor it from day one.
Today
Guard your own agents: policies, approvals, spend limits, audit logs, kill switches, webhooks, SDKs.
Next
Registry metadata for every agent and tool — categories, risk levels, required permissions, policy bindings, and usage history.
The vision
A marketplace where agents and capabilities ship with governance built in — so adopting an agent doesn't mean trusting it blindly.
Built for teams that have to answer questions
Tenant isolation
Every query is scoped to your organization. API keys are stored as SHA-256 hashes; passwords use scrypt.
Verifiable webhooks
All webhook deliveries are HMAC-SHA256 signed with a per-endpoint secret shown exactly once.
Payments via Stripe
Card data never touches Ruligent. Stripe webhook events are signature-verified with replay protection.
use a private deployment option
available for private deployment. Run the whole gateway on your own infrastructure if your data can't leave.
Common questions
Does Venture Mode run my business for me?
No. Venture Mode is AI-assisted venture execution with governance — agents draft, analyze, and execute only the workflows you approve. You remain the owner and operator, you make the decisions, and you own the outcomes. Nothing here guarantees success, revenue, or a launch.
What do agents actually do today?
Analysis and drafting: opportunity/validation reports with a BUILD, PIVOT, RESEARCH_MORE, or STOP recommendation; PRDs and roadmaps; read-only repository analysis and implementation plans; UX reviews and brand guides; launch copy drafts; growth experiment plans; and deterministic launch-readiness scoring. Actions with external side effects — sending anything outside your org, spending money, deleting data, deploying to production — ship behind always-approval rails, so a human signs off no matter the autonomy level.
What happens without an LLM key?
Agent document tasks fail closed with a clear llm_not_configured error — nothing is fabricated. Deterministic tasks (launch-readiness scoring, the raw repository analysis) still work, because they compute from real project state, not a model.
Does Ruligent add latency to every tool call?
The guard check is a single HTTP round trip before the action runs — typically tens of milliseconds against a nearby deployment. You choose which tools to guard; low-risk reads can skip the gate entirely, and you can use a private deployment next to your agents.
What happens if Ruligent is unreachable?
You decide per call. The SDKs support fail-closed (the action is denied if the gate can't be reached — the default for risky tools) or fail-open (the action proceeds and is logged when connectivity returns) so availability trade-offs are explicit, not accidental.
Does this guarantee my agents are safe?
No — and you should be skeptical of anyone who says otherwise. Ruligent enforces the policies you configure and records what happened. It reduces the blast radius of agent mistakes and gives you evidence and controls; it does not make an unsafe agent safe, and you remain responsible for what your agents do.
How is this different from LLM guardrail libraries?
Output guardrails validate what a model says. Ruligent governs what an agent does — the tool call itself — with organizational policy, human approval, spend limits, and an audit trail that survives the process that made the call.
Can I run it myself?
Yes. The core gateway is available for private deployment and runs on Node with SQLite or Postgres. Deploy it on your own infrastructure, or use our hosted version and export your data whenever you want.
Do you handle prompt injection?
Ruligent is the enforcement layer, not an input filter: even if an agent is manipulated into attempting a dangerous action, the gate still applies your policies — payments still need approval, deletes are still blocked, spend caps still hold. Pair it with input/output filtering for defense in depth.
Give your agents a gate.
Sign up, get an API key immediately, and guard your first agent action in under 15 minutes.