Skip to main content
Start with the Free Sandbox to protect one risky node, see real decision logs, and only then widen the rollout.
1

Install

Add the VerifiedX package for your runtime.
pip install verifiedx
This page shows the raw runtime path because it is the fastest universal install. If your app already uses OpenAI direct, OpenAI Agents SDK, Anthropic direct, Claude Agent SDK, LangGraph, LangChain, Vercel AI SDK, or MCP, prefer the native adapter page for that stack.
2

Set environment variables

For the hosted service, VERIFIEDX_API_KEY is the only required variable.
.env
VERIFIEDX_API_KEY=vxpk_your_runtime_key

# Optional
VERIFIEDX_BASE_URL=https://api.verifiedx.me
VERIFIEDX_ORG_ID=your_org_id
VERIFIEDX_PROJECT_ID=your_project_id
VERIFIEDX_ENVIRONMENT=prod
VERIFIEDX_BASE_URL already defaults to https://api.verifiedx.me. Org, project, and environment also have SDK defaults, so they are optional for a first install.
3

Bind your node

Bind the methods VerifiedX should observe and preflight. For the raw runtime, that usually means your LLM call, retrieval method, and the first risky action or durable memory write you want to protect.
from verifiedx import init_verifiedx

class WorkflowNode:
    def call_model(self, messages):
        ...

    def lookup_internal_workflow(self, workflow_id):
        ...

    def set_workflow_status(self, workflow_id, status):
        ...

vx = init_verifiedx()
node = WorkflowNode()

vx.install_runtime(
    node,
    llm={"call_model": {"model_name": "gpt-5.4-mini"}},
    retrievals={"lookup_internal_workflow": {"query": "internal workflow evidence"}},
    actions={"set_workflow_status": {"tool_name": "set_workflow_status"}},
)
If the first risky node you want to protect is a durable memory write instead of an action, bind it under memories instead of actions.
If the node you are protecting is part of a larger multi-agent or agent+human workflow, pass upstream context into VerifiedX so that node has better system and situational awareness before it takes a high-impact action. VerifiedX does not require a fixed schema for this. Pass the upstream context you already have in any JSON-serializable shape.
4

Run your agent and check your logs

Run your agent as normal. VerifiedX observes the run, preflights the protected side effect before it lands, and records a decision receipt you can inspect.Open the VerifiedX dashboard to inspect your decision logs. Each protected action check includes:
  • The action that was intercepted
  • The preflight outcome: allow, allow_with_warning, replan_required, or goal_fail_terminal
  • Structured reasons explaining the decision
  • A machine-readable decision receipt with routing and resume semantics
If a replan happens, the side effect does not execute. The agent gets loopback guidance and can keep working toward the same goal through a safer next step.

​
Tell your coding agent

Use this prompt to have a coding agent integrate VerifiedX into an existing codebase for you.

Agent integration prompt

You are integrating VerifiedX into an existing codebase.

Goal
Install VerifiedX into this codebase with the smallest truthful integration. Keep the existing runtime, tools, prompts, orchestration, and business logic. Use VERIFIEDX_API_KEY from env. Prefer the native adapter that exactly matches the runtime or framework already used by this codebase.

First step
Read the codebase and identify which VerifiedX integration surface matches it. Before editing, open the matching docs page:

- Python raw: https://docs.verifiedx.me/sdks/python
- TypeScript raw: https://docs.verifiedx.me/sdks/typescript
- OpenAI Agents SDK: https://docs.verifiedx.me/sdks/openai-agents-sdk
- Claude Agent SDK: https://docs.verifiedx.me/sdks/claude-agent-sdk
- Vercel AI SDK: https://docs.verifiedx.me/sdks/vercel-ai
- LangGraph: https://docs.verifiedx.me/sdks/langgraph
- OpenAI direct: https://docs.verifiedx.me/sdks/openai
- Anthropic direct: https://docs.verifiedx.me/sdks/anthropic
- LangGraph (OpenAI): https://docs.verifiedx.me/sdks/langgraph-openai
- LangGraph (Anthropic): https://docs.verifiedx.me/sdks/langgraph-anthropic
- MCP (Python): https://docs.verifiedx.me/sdks/mcp-python
- MCP (TypeScript): https://docs.verifiedx.me/sdks/mcp-typescript

Concept references
If you need the runtime model or blocked-result semantics while integrating, use these:

- How it works: https://docs.verifiedx.me/concepts/how-it-works
- Protected actions: https://docs.verifiedx.me/concepts/protected-actions
- Decision receipts: https://docs.verifiedx.me/concepts/decision-receipts

Use these pages to understand:
- what should be protected first
- what counts as a protected action vs a support input
- how blocked results, loopbacks, and decision receipts should be handled

Do not use the concept pages to invent API names. Use the matching SDK page for exact installation and code.

Selection rules
- Use the highest-level native adapter already owning the tool loop, graph, or runtime in this codebase.
- If the codebase uses OpenAI Agents SDK, use the OpenAI Agents SDK adapter, not OpenAI direct.
- If the codebase uses Claude Agent SDK, use the Claude Agent SDK adapter, not Anthropic direct.
- If LangGraph owns the graph or tool loop, use the LangGraph adapter path, not the direct provider adapter.
- If the codebase exposes standalone MCP tool handlers, use the MCP Python or MCP TypeScript adapter.
- Only use the raw Python or raw TypeScript runtime if the codebase does not already use a supported native adapter surface.

Context
Start with one risky node only. VerifiedX checks a pending high-impact action using what the agent is about to do, what it has already done in the run, the evidence gathered before the action, and upstream context when the node is part of a multi-agent or agent+human workflow.

Success criteria
- VerifiedX is installed through the exact supported surface already used by this codebase.
- The runtime key is loaded from env, not hardcoded.
- Existing app behavior stays the same except for VerifiedX protection, loopback behavior, and decision receipts.
- One real risky node is protected first.

Implementation rules
- Read the existing code first, then make the smallest truthful integration.
- Apply the change in the real codebase. Do not stop at prose or TODO comments.
- Use the exact VerifiedX API names from the matching SDK page.
- If the protected node is part of a composed system, pass the upstream context already available in the codebase into VerifiedX. Do not invent a new schema.
- In Python, use `with_upstream_context(...)` or `set_upstream_context(...)` when needed.
- In TypeScript, use `withUpstreamContext(...)` or `setUpstreamContext(...)` when needed.
- If the project does not already use a supported adapter, use `init_verifiedx()` + `install_runtime(...)` in Python or `initVerifiedX()` + `bindHarness(...)` in TypeScript.
- Do not invent old semantic config such as `userInstructions`, `pendingAction`, or `pendingMemoryWrite`.
- Do not add custom policy code or redesign the workflow.