Get up and running in under 2 minutes — from the web or the terminal.

Option A: Web App

1. Sign up at /portal
2. Create a project in the OS shell (New Project app)
3. Chat with your agents from the Agent Chat app

Option B: CLI

# Install
bun add -g pantheon-cli

# Create account (or login if you have one)
pantheon signup

# Initialize your project
cd your-project
pantheon init

# Start chatting
pantheon chat engineer

Option C: Web + CLI Together

Use the web for visual management and the CLI for terminal workflows. Both share the same backend.

1. Sign up on the web at /portal
2. Go to Settings > API Keys and generate a key
3. In your terminal:

pantheon login --api-key
# Paste your bos_live_... key

API keys let you authenticate without email/password. Use them for the CLI, CI pipelines, and programmatic access.

Generate from the Web

1. Open the OS shell and launch Settings
2. Go to API Keys in the sidebar
3. Click "+ Create API Key", name it, and copy the key
4. Keys start with bos_live_ and are shown only once

Generate from the CLI

# Must be logged in first (email/password or existing key)
pantheon api-keys --create

# List your keys
pantheon api-keys

# Revoke a key
pantheon api-keys --revoke <key-id>

Use an API Key

# CLI login with API key
pantheon login --api-key

# Direct API usage (any HTTP client)
curl -H "Authorization: Bearer bos_live_your_key_here" \
  https://api.pantheonos.dev/api/v1/me

The Pantheon CLI gives you full access to your AI team from the terminal.

bun add -g pantheon-cli

Authentication

Project Setup

Agent Interaction

Monitoring

Settings

See the interactive CLI playground for demos of each command.

Every project gets 6 specialized AI agents, each defined by its role.

Plus the Overseer — the system monitor that watches thresholds across all projects and alerts you when action is needed.

Pantheon connects to the tools your team already uses. Each connector provides read, write, and watch capabilities with governance baked in.

Available Connectors

Connecting a Service

1. Go to Settings → Connectors in the OS shell
2. Click Authorize on the service you want
3. Complete the OAuth flow in the popup
4. The connector is now active for your project

Policies define what agents can and cannot do. They control which tools require approval and who can approve them.

Default Policy

By default, all read-only tools are auto-allowed and all write tools require human approval. This is the safest starting point.

Custom Policies (Team Plan)

On the Team plan, you can define role-based approval rules:

# policies.yaml
approval_rules:
  # Production deploys need admin/owner approval
  - tool: github_push_file
    target: main
    requires_role: [admin, owner]

  # Staging deploys auto-approved for members
  - tool: github_push_file
    target: staging
    requires_role: [member, admin, owner]
    auto_approve: true

  # High-value Stripe actions need owner only
  - tool: stripe_*
    amount_above: 1000
    requires_role: [owner]

How Policies Are Evaluated

1. Agent requests a tool action
2. Policy engine checks the tool against all rules
3. If a rule matches: action is allowed, queued for approval, or denied based on the user's role
4. If no rule matches: default policy applies (write tools → approval required)

Connect a Telegram group to your project so agents can post updates, briefings, and alerts directly to your team.

Setup

1. Create a Telegram group (or use an existing one)
2. Add @PantheonOSBot to the group
3. Type /connect your-project-id in the group
4. The bot will confirm and your agents are now active

Bot Commands

Talking to Agents

Once connected, message any agent by name:

strategist what should we focus on this week?
engineer review the auth module
analyst what's our runway?

What Agents Post

Receive real-time events when things happen in your projects. All payloads are signed with HMAC-SHA256.

Events

Payload Format

{
  "event": "approval.pending",
  "timestamp": "2026-04-08T09:14:32Z",
  "data": {
    "approvalId": "abc-123",
    "projectId": "my-saas",
    "agent": "deployer",
    "actionType": "deploy",
    "summary": "Deploy v2.1.0 to production"
  }
}

Verify the signature using the X-Pantheon-Signature header with your webhook secret.

Bring the agents you already run — CrewAI, LangGraph, Claude Code, custom scripts — onto the same tamper-evident record and approval queue as Pantheon's own agents. Two endpoints, one API key. Alpha: the API below is live; the full Open Agent Record ingestion spec (signing, portability) is still in development.

The contract

Authenticate every call with Authorization: Bearer bos_live_... (see API Keys). Sources: claude-code, cursor, crewai, langgraph, custom.

Record an action (fire-and-forget)

curl -X POST https://api.pantheonos.dev/api/v1/oar/ingest \
  -H "Authorization: Bearer bos_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "source": "crewai",
    "sessionId": "run-42",
    "events": [{
      "tool": "send_email",
      "summary": "Sent onboarding email to lead@acme.com",
      "status": "executed"
    }]
  }'

Gate a risky action (policy decides, human decides, you act)

The gate runs your org's policy engine first — the same one governing Pantheon's own agents. Three outcomes: allow (an org rule explicitly permits it — auto-approved on the record, no human needed), deny (org policy forbids it), or require_approval (the fail-closed default for anything unclassified — a human gets a one-tap card).

curl -X POST https://api.pantheonos.dev/api/v1/oar/gate \
  -H "Authorization: Bearer bos_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "source": "crewai", "tool": "shell",
    "summary": "rm -rf ./build && deploy to prod",
    "idempotencyKey": "run-42-step-3-deploy",
    "waitSeconds": 60
  }'
# allow:            {"decision": "allow", "policyRule": "external:read_*"}
# deny:             {"decision": "deny", "reason": "…"}
# human approved:   {"decision": "require_approval", "approvalId": "…", "status": "approved"}
# still waiting:    {"decision": "require_approval", "approvalId": "…", "status": "pending"}
#                   → keep polling GET /api/v1/approvals/<approvalId>

• idempotencyKey — retries return the same approval card instead of minting a twin. Use a stable key per action (run id + step).
• waitSeconds (≤ 60) — the server holds the request while the human decides; the happy path is one round-trip, no poll loop.
• Attention budget — more than 25 pending external approvals returns 429. A runaway agent gets refused, not a hundred cards.
• Push instead of poll — subscribe a webhook to approval.resolved and skip polling entirely.

Python: wrap any CrewAI / LangGraph tool

import time, uuid, requests

BASE = "https://api.pantheonos.dev"
KEY = {"Authorization": "Bearer bos_live_..."}

def governed(tool_name: str, summary: str, run, run_id: str = ""):
    """Gate an action through Pantheon's policy engine + human approval,
    then record the outcome on the tamper-evident chain."""
    r = requests.post(f"{BASE}/api/v1/oar/gate", headers=KEY, json={
        "source": "crewai", "tool": tool_name, "summary": summary,
        "idempotencyKey": f"{run_id or uuid.uuid4()}:{tool_name}",
        "waitSeconds": 60,        # server holds while the human decides
    }, timeout=90).json()

    if r.get("decision") == "deny":
        raise PermissionError(f"Denied by org policy: {r.get('reason')}")
    if r.get("decision") == "require_approval":
        status = r.get("status")
        while status == "pending":     # fallback poll past the long-poll window
            time.sleep(3)
            status = requests.get(
                f"{BASE}/api/v1/approvals/{r['approvalId']}", headers=KEY
            ).json()["approval"]["status"]
        if status != "approved":
            raise PermissionError("Rejected by reviewer")

    result = run()  # allowed by policy, or a human said yes — do the thing
    requests.post(f"{BASE}/api/v1/oar/ingest", headers=KEY, json={
        "source": "crewai",
        "events": [{"tool": tool_name, "summary": summary, "status": "executed"}],
    })
    return result

# CrewAI: call from inside any custom tool before the side effect.
# LangGraph: call inside the node that performs the action — the wait
# is your human-in-the-loop interrupt, no graph changes needed.

Approvals expire after 7 days; a gate that is never approved never executes — fail-closed, same as Pantheon's own agents. Events appear in your Audit Log with actor type external and verify with the rest of your chain via GET /api/v1/oar/verify.

Customize agent behavior per project using workspace config files or the web onboarding.

CLI: .pantheon/ Files

When you run pantheon init, a .pantheon/ directory is created with:

Edit these files anytime — agents read them on every message.

Web: Workspace Notes

When creating a project through the web onboarding, you can add "Notes for your agents" in the Priorities step. These are stored in the database and serve the same purpose as .pantheon/ files.