Bartholomew Developer Documentation

Compiled zero-overhead Agentic Runtime Protection (ARP). Operates strictly in-process with microsecond-latency µs execution latency, eliminating 200ms–1,500ms network round-trip bottlenecks.

The Token Tollbooth Reverse Proxy & M2M Autonomous Rail (HTTP 402)

A zero-refactoring, drop-in reverse proxy that sits transparently between your agent swarms and upstream LLM providers (OpenAI, Anthropic, DeepSeek). Automatically compresses prompt tokens in-flight by 25% to 35%, eliminates boilerplate, enforces invariant constraints, and exposes an autonomous machine-to-machine micropayment rail (HTTP 402).

# Drop-in OpenAI-compatible chat completion through Bartholomew Tollbooth
curl -i -X POST https://proxy.bartholomew.info/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "X-BTP-Passkey: PSMITH-PRO-YOUR-KEY" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {"role": "system", "content": "You are a software security assistant."},
      {"role": "user", "content": "Please could you kindly review this code and make sure to find bugs."}
    ]
  }'

# Live Output Headers:
# X-PromptSmith-Tokens-Original: 28
# X-PromptSmith-Tokens-Compressed: 18
# X-PromptSmith-Tokens-Saved: 10
# X-PromptSmith-Efficiency-Pct: 35.7%
# X-PromptSmith-Cost-Reduction-USD: $0.000050

from openai import OpenAI
import os

# Point base_url to the Bartholomew reverse proxy tollbooth
client = OpenAI(
    base_url="https://proxy.bartholomew.info/v1",
    api_key=os.getenv("OPENAI_API_KEY"),
    default_headers={"X-BTP-Passkey": os.getenv("BTP_PASSKEY", "PSMITH-PRO-YOUR-PASSKEY")}
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are an automated code generator."},
        {"role": "user", "content": "Please write a resilient worker thread in Python."}
    ]
)

print(response.choices[0].message.content)

import os
from langchain_openai import ChatOpenAI

# Intercept and trim tokens transparently across all LangChain agents
llm = ChatOpenAI(
    model="gpt-4o",
    openai_api_base="https://proxy.bartholomew.info/v1",
    openai_api_key=os.getenv("OPENAI_API_KEY"),
    default_headers={"X-BTP-Passkey": os.getenv("BTP_PASSKEY")}
)

result = llm.invoke("Please analyze and compress this architectural document.")
print(result.content)

import requests

# Autonomous agent handling HTTP 402 Payment Required toll gate
PROXY_URL = "https://proxy.bartholomew.info/v1/chat/completions"
SETTLE_URL = "https://proxy.bartholomew.info/v1/m2m/settle"

payload = {
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Execute high-density code refactoring."}]
}

resp = requests.post(PROXY_URL, json=payload)

if resp.status_code == 402:
    print("[M2M Protocol] HTTP 402 Payment Required detected. Settle rail:", resp.headers.get("X-BTP-Checkout-Rail"))
    
    # Machine-to-Machine programmatic settlement via Keystone Passkey ($0.99/wk)
    settle_resp = requests.post(SETTLE_URL, json={
        "client_id": "autonomous-agent-01",
        "passkey": "PSMITH-PRO-SWARM-PASSKEY",
        "requested_quota": 50000
    })
    
    if settle_resp.status_code == 200:
        print("[M2M Protocol] Toll cleared autonomously. Re-submitting payload...")
        resp = requests.post(
            PROXY_URL,
            json=payload,
            headers={"X-BTP-Passkey": "PSMITH-PRO-SWARM-PASSKEY"}
        )
        print(resp.json())

REST API & Cloud Endpoints

In addition to native SDK bindings, Bartholomew exposes low-latency stateless HTTP endpoints for microservices, CI/CD runners, and edge agents. Full specification available at /openapi.json →

curl -X POST https://bartholomew.info/api/v1/sanitize \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_BTP_KEY" \
  -d '{
    "payload": "Please review AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY and rm -rf /",
    "agent_id": "claude-code-subagent-01",
    "strict_mode": true
  }'

# Response (< 20 µs):
{
  "status": "SANITIZED",
  "safe": true,
  "redacted_tokens": 1,
  "blocked_invariants": ["CATASTROPHIC_SHELL_DELETION"],
  "clean_payload": "Please review AWS_SECRET_ACCESS_KEY=[REDACTED] and [BLOCKED_OPERATION]",
  "signature": "ed25519:7c92b49e0a81..."
}

curl -X POST https://bartholomew.info/api/v1/validate \
  -H "Content-Type: application/json" \
  -d '{
    "agent_passport": "nhi:btp:ed25519:3a890f841...",
    "action": "execute_tool",
    "tool_name": "postgres_db_query"
  }'

# Response:
{
  "authorized": true,
  "identity": "nhi:btp:ed25519:3a890f841...",
  "rate_limit_remaining": 99998,
  "attestation_timestamp": 1790800000
}

import httpx

resp = httpx.post(
    "https://bartholomew.info/api/v1/sanitize",
    json={"payload": agent_prompt, "agent_id": "agent-alpha"},
    headers={"Authorization": "Bearer YOUR_BTP_KEY"}
)
clean_data = resp.json()["clean_payload"]

const res = await fetch("https://bartholomew.info/api/v1/sanitize", {
  method: "POST",
  headers: { "Content-Type": "application/json", "Authorization": "Bearer YOUR_BTP_KEY" },
  body: JSON.stringify({ payload: agentPrompt, agent_id: "agent-node" })
});
const { clean_payload, safe } = await res.json();

Docker Hermetic Sandbox

For production deployments requiring hardware-level process isolation, run untrusted agent code within the hermetic Bartholomew Docker runtime:

# Run isolated container with compiled Bartholomew invariant enforcement:
docker run -d \
  --name btp-sandbox \
  --security-opt seccomp=unconfined \
  --cap-drop=ALL \
  --read-only \
  -p 8080:8080 \
  bartholomew/guard:v7.0.0

# Execute an untrusted agent payload inside the hermetic container:
docker exec btp-sandbox btp-guard run -- "python agent_script.py"

Bonded Agent Warranty Fund ($100,000 Pool)

Bartholomew operates an algorithmic $100,000 USD reserve pool that underwrites autonomous agent execution. Enterprise teams can issue bonded policies guaranteeing microsecond-latency gating SLAs and zero uncontained data exfiltration.

# 1. Check live reserve pool status:
$ btp-guard bond pool

# 2. Underwrite a $50,000 execution bond for an agent:
$ btp-guard bond issue --agent "autonomous-trading-bot-01" --coverage 50000

# 3. In Python runtime:
from btp_guard import WarrantyFundManager

fund = WarrantyFundManager()
policy = fund.issue_policy(agent_id="agent-01", coverage_usd=50000.0)
print(f"Policy Active: {policy['policy_id']} | Merkle Bond: {policy['bond_hash']}")

Bartholomew operates on a transparent, developer-first capability passkey architecture. Passkeys unlock high-throughput in-process AST gating, in-flight secret scrubbing, FIPS 186-5 Ed25519 Merkle receipts, and cross-agent micro-toll budgeting without recurring seat locks or cloud vendor lock-in.

Activating Your Passkey in 60 Seconds

# Add to your project root .env or export in shell
BTP_PASSKEY="btp_live_948f2a1b7c093e4b7a19280d94f281e05a8b7c3d"

# Python
from btp_guard import protect_agent

# Protect Cursor / Claude Code / CrewAI tools
guard = protect_agent(passkey="btp_live_...")
print(f"Bartholomew Keystone Verified: {guard.status}")

# Attest local capability quota and Merkle signature root
btp keystone verify --token $BTP_PASSKEY

Model Context Protocol (MCP) Clearinghouse

Autonomous agents pay each other for MCP tool executions in real-time. The Bartholomew Clearinghouse acts as an in-line micro-escrow and safety validator, ensuring tool payloads pass AST inspection before micropayments settle.

# Settle a paid MCP tool invocation ($0.10 price with 2.5% take-rate):
$ btp-guard mcp-settle \
    --agent "claude-code-worker" \
    --tool "postgres_query" \
    --payload '{"query": "SELECT COUNT(*) FROM telemetry"}' \
    --price 0.10

# Output:
# [+] [MCP CLEARINGHOUSE] Tool Execution Approved (14.2µs)
#   - Protocol Fee (2.5%): $0.0025 USD
#   - Tool Provider Payout: $0.0975 USD
#   - Merkle Settlement Seal: f4a890...710c

Universal Dynamic Schema Engine & AST Gating

Seamlessly ingest, harmonize, and validate any tool schema across Anthropic Claude, OpenAI, Google Gemini, OpenAPI 3.x, and JSON Schema 2020-12 with zero manual adapter boilerplate. Executes in-process type validation, secret redaction, and destructive command interception in 3.2 µs.

# 1. Harmonize any arbitrary schema (Claude, OpenAI, Gemini, OpenAPI) to BTP Universal Contract:
$ npx btp-guard schema harmonize ./my_tool_spec.json

# 2. In-process microsecond-latency dynamic schema & AST invariant validation:
$ npx btp-guard schema validate ./schema.json ./payload.json
[PASS] Invariant Verified (< 3.2 µs) - 0 vulnerabilities, secrets scrubbed in-flight

# 3. Browse all 40 registered universal security tools in chosen format:
$ npx btp-guard schema catalog --format=claude
$ npx btp-guard schema catalog --format=openai
$ npx btp-guard schema catalog --format=gemini

Cross-IDE Unified Marketplace Distribution

Single-command deployment and workspace immunization across Cursor, Windsurf, Claude Code, and VS Code.

# Cursor IDE:
$ cursor --install-extension Bartholomew.bartholomew-guard-vscode

# Windsurf Cascade:
$ windsurf --install-extension Bartholomew.bartholomew-guard-vscode

# Claude Code / Anthropic MCP:
$ claude mcp add btp-guard npx -y btp-guard mcp-serve

# VS Code / Open VSX:
$ code --install-extension Bartholomew.bartholomew-guard-vscode

# 1-Click Workspace Immunization (.cursorrules, CLAUDE.md, .windsurfrules):
$ npx btp-guard arm

SOC 2 & EU AI Act Compliance Export

Automate security audits, vendor risk assessments, and compliance filings. Every Bartholomew invariant execution produces an immutable, cryptographically verifiable ledger mapped to SOC 2 Type II trust principles and EU AI Act Article 14 human oversight requirements.

# Export complete SOC 2 Type II compliance audit bundle:
$ btp-guard audit export --format=soc2 --output=audit_soc2_dossier.json

# Verify zero uncontained data exfiltrations or unauthorized tool invocations:
$ btp-guard audit verify --dossier=audit_soc2_dossier.json
[+] [BTP COMPLIANCE] 100% Invariant Integrity Verified (2,927 vectors)
[+] Mapped Trust Services Criteria: CC6.1, CC6.6, CC7.1