Quickstart

Get quint-agent running in 2 minutes.

1. Install

pip install quint-agent

2. Get an API key

Go to cloud.quintai.dev/settings and create an SDK API key. It starts with qak_.

3. Initialize

import quint_agent

quint_agent.init(api_key="qak_your_key_here")

Or set the environment variable:

export QUINT_API_KEY=qak_your_key_here

import quint_agent
quint_agent.init()  # reads from QUINT_API_KEY

4. Guard your tools

@quint_agent.guard()
def read_file(path: str) -> str:
    return open(path).read()

@quint_agent.guard()
def run_command(cmd: str) -> str:
    import subprocess
    return subprocess.check_output(cmd, shell=True, text=True)

@quint_agent.guard()
def query_db(sql: str) -> list:
    return db.execute(sql).fetchall()

Every call is now:

• Captured — tool name, arguments, result, timing
• Policy-checked — blocked if it violates your security rules
• Streamed — async telemetry to Quint cloud (non-blocking)

5. See it in the dashboard

Open cloud.quintai.dev. Your agent’s session appears in real-time with every tool call, policy decision, and behavioral signal.

What happens when a tool is blocked

from quint_agent import ToolBlockedError

try:
    read_file(path="/home/user/.env")
except ToolBlockedError as e:
    print(f"Blocked: {e}")
    # Blocked: tool 'read_file' denied by rule 'deny-dotenv': argument 'path' matches '*.env'

The agent receives the error and can decide what to do — retry with different arguments, ask the user, or move on.

Framework integrations

Anthropic

import anthropic
import quint_agent
from quint_agent.integrations.anthropic import guarded_dispatch

quint_agent.init(api_key="qak_...")
client = anthropic.Anthropic()

tools_map = {"read_file": read_file, "run_command": run_command}
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=[...],
    messages=[{"role": "user", "content": "List the project files"}],
)

for block in response.content:
    if block.type == "tool_use":
        result = guarded_dispatch(block.name, block.input, tools_map)

LangChain

from quint_agent.integrations.langchain import QuintCallbackHandler

quint_agent.init(api_key="qak_...")

chain = create_tool_agent(llm, tools, prompt)
chain.invoke(
    {"input": "What's in the project?"},
    config={"callbacks": [QuintCallbackHandler()]},
)

MCP

from quint_agent.integrations.mcp import QuintMCPClient

quint_agent.init(api_key="qak_...")

async with mcp_client() as session:
    guarded = QuintMCPClient(session)
    result = await guarded.call_tool("read_file", {"path": "/x"})

Next steps

Policy DSL

Write YAML rules to control what your agents can do

API Reference

Full reference for init(), guard(), and integrations