Frameworks

Veris supports any agent framework. Your agent runs unmodified inside the sandbox — Veris talks to it through whatever production interface it already exposes.

Four frameworks are natively supported, meaning Veris understands their trace format for full observability (multi-agent traces, tool-call tracking, per-agent system prompts):

Use this page when you want framework-specific gotchas or setup notes. Most of what’s here is also encoded in the agent-integration skill , so if you’re using a coding agent to integrate, you probably don’t need to read this directly.

LLM provider base URLs

The Veris LLM proxy intercepts provider domains (api.openai.com, api.anthropic.com, Azure OpenAI, etc.) via DNS, so setting the provider’s API key with veris env vars set --secret is usually enough.

Some frameworks don’t default the base URL and crash at startup with unsupported protocol scheme "" unless one is set. If your framework exposes a base_url option (e.g. inference-gateway/adk’s A2A_AGENT_CLIENT_BASE_URL), point it at the real provider URL — DNS interception still routes it to the proxy.

.veris/veris.yaml


agent:
  environment:
    A2A_AGENT_CLIENT_BASE_URL: https://api.openai.com/v1

Framework-specific notes

OpenAI Agents SDK

Works out of the box with an HTTP channel. Expose your agent as an HTTP server (FastAPI, Flask, Express, etc.) wrapping a Runner.run call; Veris drives it through the same interface.

No framework-specific configuration required beyond what’s in Quickstart.

LangGraph

LangGraph agents that wrap the compiled graph in a custom HTTP server (FastAPI, Express, etc.) integrate via the HTTP channel like any other agent.

Agents that deploy via LangGraph Platform ship only a langgraph.json — there’s no existing Python entry point for Veris to call, so you write a small driver that compiles the graph and invokes it through the function channel:

.veris/veris_handler.py


import uuid
from langchain_core.messages import HumanMessage
from langgraph.checkpoint.memory import MemorySaver
from my_agent.graph import graph_builder
 
_graph = graph_builder.compile(checkpointer=MemorySaver())
_thread_id = str(uuid.uuid4())
 
async def handle_message(message: str) -> str:
    result = await _graph.ainvoke(
        {"messages": [HumanMessage(content=message)]},
        config={"configurable": {"thread_id": _thread_id}},
    )
    return result.get("final_report") or result["messages"][-1].content

.veris/veris.yaml


actor:
  config:
    MAX_TURNS: "3"
  channels:
    - type: function
      callable: veris_handler:handle_message
 
agent:
  code_path: /agent

MemorySaver mirrors the Postgres-backed checkpointer Platform attaches at deploy time. The stable thread_id lets successive actor turns share state (needed for clarify → reply → report handshakes). Adjust the response-extraction key (final_report) to match your graph’s output field. Copy .veris/veris_handler.py into code_path from the Dockerfile so it’s importable.

Google ADK

Google ADK agents typically expose an HTTP server. The gotcha is the base URL — ADK’s inference gateway doesn’t set one by default. Use the callout above: set A2A_AGENT_CLIENT_BASE_URL in agent.environment to your provider’s real URL. DNS interception still routes it to the Veris proxy.

A2A / JSON-RPC adapter

ADK agents commonly speak A2A (Google’s agent-to-agent protocol, built on nested JSON-RPC) rather than flat HTTP. Veris’s HTTP channel sends flat top-level JSON ({message, session_id}); A2A wraps the user’s text at params.message.parts[0].text and returns a task you poll via tasks/get until terminal. Bridge the two with a short adapter that runs next to the agent — the agent itself is unmodified.

.veris/veris_adapter.py


import json, os, time, uuid, urllib.request
from http.server import BaseHTTPRequestHandler, HTTPServer
 
A2A_URL      = os.environ["A2A_URL"]                        # http://localhost:8080/a2a
ADAPTER_PORT = int(os.environ.get("ADAPTER_PORT", "8008"))
 
# A2A spec lowercase + framework proto-enum form (e.g. ADK < 1.0).
TERMINAL = {"completed","failed","canceled","cancelled","rejected",
            "input-required","auth-required",
            "TASK_STATE_COMPLETED","TASK_STATE_FAILED","TASK_STATE_CANCELLED",
            "TASK_STATE_REJECTED","TASK_STATE_INPUT_REQUIRED","TASK_STATE_AUTH_REQUIRED"}
 
def rpc(method, params):
    body = json.dumps({"jsonrpc":"2.0","id":str(uuid.uuid4()),
                       "method":method,"params":params}).encode()
    req = urllib.request.Request(A2A_URL, data=body,
        headers={"Content-Type":"application/json"}, method="POST")
    with urllib.request.urlopen(req, timeout=120) as r:
        return json.loads(r.read()).get("result") or {}
 
def text_of(result):
    for src in (result.get("artifacts") or [], [result]):
        for item in src:
            for p in item.get("parts") or []:
                if p.get("text"): return p["text"]
    return ""
 
def handle(message, session_id):
    mid = str(uuid.uuid4())
    msg = {"role":"user","messageId":mid,"parts":[{"kind":"text","text":message}]}
    if session_id: msg["contextId"] = session_id
    result = rpc("message/send", {"message": msg})
    while "status" in result and result["status"].get("state") not in TERMINAL:
        time.sleep(1)
        result = rpc("tasks/get", {"id": result["id"]})
    return text_of(result), result.get("contextId") or session_id
 
class H(BaseHTTPRequestHandler):
    def do_POST(self):
        data = json.loads(self.rfile.read(int(self.headers["Content-Length"])) or b"{}")
        try:
            text, ctx = handle(data.get("message",""), data.get("session_id",""))
            body = json.dumps({"response": text, "session_id": ctx}).encode()
            self.send_response(200)
        except Exception as e:
            body = json.dumps({"response":"", "error": str(e)}).encode()
            self.send_response(500)
        self.send_header("Content-Type","application/json"); self.end_headers()
        self.wfile.write(body)
    def log_message(self, *a): pass
 
HTTPServer(("0.0.0.0", ADAPTER_PORT), H).serve_forever()

Start the agent and adapter together, then point the actor at the adapter’s port:

.veris/start.sh


#!/bin/bash
set -e
./my-agent &
until curl -sf http://localhost:8080/health >/dev/null 2>&1; do sleep 1; done
exec python3 veris_adapter.py

.veris/veris.yaml


actor:
  channels:
    - type: http
      url: http://localhost:8008/
      request:  { message_field: message, session_field: session_id }
      response: { type: json, message_field: response, session_field: session_id }
 
agent:
  code_path: /agent
  entry_point: bash start.sh
  port: 8008
  environment:
    A2A_URL: http://localhost:8080/a2a

The same adapter pattern works for any agent speaking A2A or another nested JSON-RPC protocol, not just ADK.

Vercel AI SDK

The Vercel AI SDK requires an explicit opt-in to emit trace data. Add experimental_telemetry to every generateText and streamText call:


const result = await generateText({
  model: openai("gpt-4o"),
  prompt: "...",
  experimental_telemetry: { isEnabled: true },
});

This applies to all AI SDK methods: generateText, streamText, generateObject, and streamObject.

Using a framework not listed?

It’ll still work — your agent runs as a plain HTTP/WebSocket/email/function/CLI process. You just won’t get framework-specific trace enrichment (multi-agent traces, tool-call tracking, per-agent system prompts stay as raw LLM spans). Reach out if you’d like native support added for a framework you’re using.