outer.bot Documentation

outer.bot is an AI-powered development workspace that never loses context. It injects your project knowledge into every AI turn, learns your patterns over time, and gives Obie — its built-in AI brain — the ability to filter noise, surface relevant history, and improve with every session.

Quick Start

You can be up and running in under two minutes.

1. Create an account — Sign up at outer.bot/signup. Community plan is free, no credit card required.
2. Open the Workspace — Go to outer.bot/workspace and sign in.
3. Create a project — Click +, enter a project name. outer.bot creates a GitHub repo and configures everything automatically. Or import an existing repo from your GitHub account.
4. Start chatting — The AI chat is in the center panel. Your project briefing is injected automatically on every message. Community users get daily messages included at no cost.
5. Add your API key for Pro — Go to Account Settings → AI Settings, paste your Anthropic, OpenAI, Groq, or Together.ai key. Pro unlocks all models, Obie Skills, Fusion Mode, and Field Test.

Plans & Pricing

Community (Free)

Community gives you full Workspace access with daily messages included at no cost. No API key or credit card required. There's no hard end date on the free tier — it's a business decision we'll make when the user base is large enough that word-of-mouth carries its own momentum, and we'll give existing users advance notice before any change.

Free requests run on available capacity across providers — Claude Haiku is the default, but if it's briefly unavailable (provider outage or rate limit), your request may be served by another provider automatically so chat keeps working. Tool-use requests are the one exception: they either wait for Claude specifically or return a clear, friendly message rather than silently degrading tool-call quality on a provider that can't serve them faithfully. Pro (BYOK) is never affected by this — it always uses your own key directly.

• outer.bot Workspace (outer.bot/workspace)
• Daily message limit, available capacity across providers
• Project briefing injection on every turn
• Basic Obie AI context filtering
• GitHub integration

Pro ($5/month — BYOK Required)

Pro requires you to bring your own API key (Anthropic, OpenAI, Groq, or Together.ai for Fusion Mode). Your provider bills you directly at their published rates — outer.bot adds $0. You get all models, all features, and Obie’s full brain.

• All AI models — Claude Sonnet/Opus, GPT-4o, Llama, DeepSeek, and more
• Obie Skills — AI learns your coding patterns and codebase over time
• Fusion Mode — custom multi-model dispatch (2–3 models) for complex problems
• Field Test — AI user testing with real browser automation
• Obie Active — 40–70% token reduction on every turn
• Smart Routing — cheap model for simple turns, full model for complex
• Session memory — context extracted and searchable across sessions
• Team collaboration

See full pricing details →

outer.bot Workspace

The Workspace at outer.bot/workspace is a browser-based AI chat environment with your project's Guardian briefing and Field Test built in. No installation required. Works on any desktop browser.

Interface Overview

• Left panel — Guardian Briefing — your project's live context (decisions, recent activity, open questions). Editable directly; Obie injects it into every chat message automatically.
• Center — AI Chat — conversational chat with your project's context pre-loaded. Supports Blueprint slash commands (see below).
• Right panel — Field Test — AI-driven browser automation that tests your live app like a real user.
• Header — project selector, model picker, context-depth toggle, AI Mode toggle, Blueprint drawer, account menu

AI Chat

The center panel is a conversational AI chat with your project's Guardian briefing automatically injected on every message. It does not read, edit, or commit files directly — it's a chat surface, not an autonomous coding agent.

• Guardian briefing pre-loaded — your project context is injected on every message. The AI knows your architecture, recent decisions, and open questions before you type.
• Model picker — switch between providers directly in the header. Each completed message shows which model actually served the response.
• Context depth — choose how much briefing context Obie injects per turn (Minimal / Focused / Full).
• AI Mode — Normal, or Fusion (Pro only; dispatches your message to Claude and DeepSeek V4 Pro in parallel and synthesizes one answer — requires both an Anthropic key and a Together.ai key in Account Settings). Tandem mode is not yet available in the Workspace.
• Blueprint drawer — view/edit/regenerate your Project Prompt and PRD, and run the Stress Test (six-perspective adversarial review), via the Blueprint icon in the header or by typing /generate-prompt, /generate-prd, or /stress-test in chat.

GitHub Integration

GitHub connection happens in Account Settings, not in the Workspace itself:

1. Connect your GitHub account from Account Settings
2. Create a new project with an auto-created repo, or import an existing repository
3. The project shows up in the Workspace's project selector with its briefing and Blueprint context loaded

The Workspace chat itself does not edit files, commit, or open pull requests.

Projects

Your account at outer.bot/account lists all your projects. From there you can:

• Create new project — outer.bot creates a GitHub repo and configures it automatically
• Import from GitHub — connect an existing repo as an outer.bot project
• Open in Workspace — launch any project in the IDE
• View briefing — see the current Guardian briefing for any project

How memory works

Every outer.bot project has a briefing — a living document that describes your project's architecture, decisions, and recent activity. It is built automatically from your AI sessions and git history, and it is injected into every AI turn so the model starts each conversation already knowing your codebase.

The briefing updates continuously. Each time you push to git.outer.bot or finish an AI turn, outer.bot revises the briefing with what changed — new files, new decisions, new context. You never write it by hand and you never paste it into a prompt; it is simply always there.

Compression

Briefings and session history can't grow forever without costing you tokens on every single turn. outer.bot compresses older material in the background: many past sessions are summarized down into a compact record that preserves the decisions and facts that still matter, while dropping the turn-by-turn detail that doesn't.

This runs asynchronously — it never blocks or slows down the request that triggered it. If a summarization job is interrupted (a server restart, a crash), it resumes cleanly rather than corrupting the briefing or losing history.

Obie Active

Obie Active is a lightweight pre-pass that runs before every main AI call. It reads your message, decides which sections of your project context are relevant, and filters the system prompt accordingly. Irrelevant sections are dropped; a brief guidance note is injected at the end.

What it does

• Reads the incoming user message
• Decides which context blocks to include (memory, PRD, cross-project insights, etc.)
• Drops irrelevant sections — typically 40–70% of input tokens saved
• Adds a focused guidance note to improve the main model’s response

Obie Skills

Your project briefing is episodic memory — what is true about this specific project right now. Skills are procedural memory — what works. A briefing tells Obie your database is called outerbot_outerbot; a skill tells Obie that backfilling a column's default before adding a NOT NULL constraint avoids locking a large table. One is a fact about your project; the other is a pattern that applies anywhere.

Skill tiers

• Project skills — specific to this project's stack and situation. Injected only when you're working in that project.
• User skills — your own habits and preferences, carried across every project you work on.
• Global skills — platform-wide patterns, contributed by users who've opted in and reviewed by a human before they ever go live (see below). Capped at one per request, and only after your project's and user's own skills have had priority.

How skills are extracted

Skills come from two sources. The richest is a completed Tandem plan — especially a step that failed, escalated, and then succeeded once resolved; that resolution is exactly the kind of lesson worth remembering. The second is any session that goes quiet for 30 minutes after showing real success signals (tests passing, you confirming something worked) — a weaker, heuristic signal, so it starts at lower confidence than a verified Tandem outcome.

Each extraction runs through the platform's own Haiku model, never your own AI provider key, and never blocks the request that triggered it.

Confidence, reinforcement, and decay

Every skill carries a confidence score. Seeing the same lesson again reinforces it — confidence rises, evidence count increases. Left alone, confidence decays slowly (about 1.5% a week) until it either gets reinforced again or falls below the threshold where it's automatically retired. A skill that contradicts an existing one doesn't overwrite it silently: the old one is quarantined for a human (or time) to resolve, and a new one is created at reduced confidence. A quarantine left unresolved for 60 days retires on its own.

You can review, edit, quarantine, restore, or retire any of your own skills from the Skills panel in the Workspace (Pro feature — Obie still uses your skills automatically either way; the panel is for managing them directly).

Fusion Mode

Fusion Mode is a Pro-only mode that dispatches your message to two models in parallel — Claude (your Anthropic key) and DeepSeek V4 Pro (your Together.ai key) — then uses a third call (Haiku, also on your Anthropic key) to synthesize the strongest combined answer. The pairing is fixed, not user-configurable: there’s no model picker or settings panel for Fusion in the Workspace today, just the Fusion toggle in the toolbar.

How it works

1. Click Fusion in the AI Mode toolbar
2. Your message is sent to Claude and DeepSeek V4 Pro in parallel
3. Each model generates its response independently
4. Obie (Haiku) reads both responses and synthesizes the strongest combined answer, streamed back to you as it’s generated

Requirements

• Pro plan — Fusion is not available on the free tier.
• Both an Anthropic key and a Together.ai key, added in Account Settings. Fusion is entirely BYOK — it never uses outer.bot’s platform key, for any of the three calls (primary, secondary, or synthesis). If either key is missing, Fusion returns an error naming exactly which one to add.

Cost implications

Every Fusion request makes three model calls on your own keys: the Claude primary call, the DeepSeek V4 Pro secondary call, and the Haiku synthesis call. That's more than a single-model request costs — see the benchmark numbers below for what that actually comes out to in practice, not just in theory.

When to use Fusion Mode

• Complex architectural decisions where you want multiple perspectives
• Hard debugging problems that require different reasoning approaches
• Any situation where you’d normally run two separate queries to compare

Tandem Engine

Tandem Engine is a planner-executor architecture for complex, multi-step coding tasks. A frontier model (Opus 4.8 or O3) reasons through your entire request once and produces a structured execution plan. Then a capable, economical model (Sonnet 4.6 or GPT-4.1) carries out each step in turn. Obie watches every step, checks conformance against the plan, and escalates to the planner only when the executor hits a genuine ambiguity — not a full re-plan, just a targeted clarification.

The result: premium-quality multi-step work at a fraction of the cost of running a frontier model end-to-end for every turn.

How Tandem Engine works

1. You submit a request in Tandem mode — Obie sends it to the planner (Opus 4.8 / O3) with your full project context and relevant Obie Skills.
2. The planner produces a structured plan — a step-by-step breakdown with success criteria, files affected, and anticipated decision points. This is one call.
3. You review the plan before execution begins — approve, cancel, or ask questions. You always see the strategy before anything runs.
4. The executor (Sonnet 4.6 / GPT-4.1) carries out each step — with full tool access: read files, write files, run commands. Obie injects the current step context into every executor turn so it stays on track.
5. Obie checks conformance after each step — did the output satisfy the success criteria? If yes, advance. If not, retry or escalate to the planner with a targeted question.

Provider pairings

Pairings are chosen automatically based on your BYOK provider — no manual model picking in Tandem mode.

Enabling Tandem Engine

Tandem Engine is available now in the outer.bot Workspace — look for the Tandem toggle in the chat toolbar. It is not yet available through the shared proxy endpoint used by external IDEs (Cursor, Windsurf, VS Code, etc.); those tools use normal single-model turns today.

When to use Tandem Engine

• Large refactors that span multiple files
• Feature implementations that require a clear sequence of steps
• Anything where you want to see and approve the strategy before execution begins
• Tasks where running a frontier model for every turn would be prohibitively expensive

Field Test — AI User Testing

Field Test is outer.bot’s AI-powered user testing tool. It launches a real Chromium browser, navigates to your app, and simulates user interactions — clicking buttons, filling forms, navigating pages — then reports what it found. No test scripts required.

What Field Test can do

• Navigate to any URL your app serves
• Click buttons, links, and interactive elements
• Fill and submit forms
• Take screenshots at each step
• Report errors, unexpected behavior, or broken flows
• Simulate multiple user personas with different goals

Running a Field Test

1. Open your project in the outer.bot Workspace
2. Click the Field Test tab in the outer.bot Panel
3. Enter the URL to test and describe what you want the AI to try
4. Click Run Test — a browser launches server-side
5. Watch screenshots and the AI’s observations appear in real time
6. Review the full report when the test completes

API Key Setup (BYOK)

Pro users bring their own API key. Your provider bills you directly at their published rates — outer.bot adds $0. BYOK is required for Pro; without a key, the Pro plan will prompt you to add one before chatting.

Memory maintenance runs on your key too. Background work like compressing long conversations and extracting reusable skills from your sessions bills to your own Anthropic key, the same way your chats do — it never runs on a shared outer.bot key. Typical cost is cents per week. Usage rows for this maintenance are tagged distinctly so you can see it separately from your own chat spend.

Supported providers

• Anthropic — key starts with sk-ant-. Enables Claude Haiku, Sonnet 4.6, Opus 4.8. Required for full agent mode (tool use).
• OpenAI — key starts with sk-. Enables GPT-4o-mini, GPT-4.1-mini, GPT-5-nano, and more.
• Groq — key starts with gsk_. Enables Llama 3.3 70B, Llama 3.1 8B — ultra-fast inference at low cost.
• Together.ai — required for Fusion Mode with DeepSeek V4 Pro (the recommended Fusion pairing). Get your key at api.together.ai/settings/api-keys.

Adding your key

1. Go to Account Settings
2. Click AI Settings
3. Paste your API key and select your default model
4. Click Save

Getting API keys

• Anthropic — console.anthropic.com → API Keys
• OpenAI — platform.openai.com/api-keys
• Groq — console.groq.com/keys
• Together.ai — api.together.ai/settings/api-keys

GitHub Connection

Connect your GitHub account to import repos and push code. Required for PR auto-creation.

1. Go to Account Settings
2. In the GitHub Integration section, click Connect GitHub
3. Authorize outer.bot on GitHub (scopes: repo, read:user)
4. You’ll be redirected back with your GitHub username shown

AI Proxy Setup (Any IDE)

outer.bot’s proxy endpoint works with any AI tool that accepts a custom API base URL — Claude Code, Cursor, Windsurf, and more. When you route through outer.bot, your project briefing is injected automatically on every message, even in your local IDE.

Find your token at outer.bot/setup after signing in. Two ways to connect:

• Recommended — base URL https://api.outer.bot/v2 in your tool’s API base URL field, and your token (obt_…) in its API key field. Works with any tool that has a separate key field, and keeps your token out of logged URLs.
• Zero-config — a single personal URL with the token baked in: https://api.outer.bot/v2/{your-token}/. No API key field needed, works with any tool that only accepts a base URL.

Both methods work indefinitely and hit the same account — use whichever your tool supports.

Claude Code

Paste this into Claude Code and it will configure itself:

Please add outer.bot's proxy to my Claude Code settings. Add "env": { "ANTHROPIC_BASE_URL": "https://api.outer.bot/v2", "ANTHROPIC_API_KEY": "obt_YOUR_TOKEN" } to my ~/.claude/settings.json, merging with any existing content.

Or, zero-config: set ANTHROPIC_BASE_URL to https://api.outer.bot/v2/YOUR_TOKEN/ and skip ANTHROPIC_API_KEY entirely.

Cursor

Settings → Models → API Base URL https://api.outer.bot/v2, API Key obt_YOUR_TOKEN. Or zero-config: paste https://api.outer.bot/v2/YOUR_TOKEN/ as the base URL with no separate key.

Windsurf

Settings → AI → Custom API endpoint https://api.outer.bot/v2, API Key obt_YOUR_TOKEN. Or zero-config: paste https://api.outer.bot/v2/YOUR_TOKEN/ as the endpoint with no separate key.

Any OpenAI-compatible SDK

import openai
client = openai.OpenAI(
    base_url="https://api.outer.bot/v2",
    api_key="obt_YOUR_TOKEN"
)

Or zero-config: base_url="https://api.outer.bot/v2/YOUR_TOKEN/" with any string as api_key.

MCP Compatibility

outer.bot also speaks MCP, so your project briefing and skills are reachable from any MCP-compatible client, not just the tools above. This is a compatibility surface: cooperative retrieval, the same way any MCP resource works. The enforcement guarantees (gates, verifier, drift ledger) only exist in proxy mode and hooks mode, so an MCP client can read your memory but nothing here makes it obey what it reads. For that, connect through proxy or hooks mode instead.

Endpoint: POST https://api.outer.bot/outerbot/mcp, authenticated the same way as the proxy endpoint (obt_YOUR_TOKEN). Two read-only tools are exposed: get_briefing and list_skills.

Git Proxy

Every push to git.outer.bot updates your project briefing automatically — what files changed, what commits say, what’s new since the last session. This is how the AI knows your project history without you typing it in.

For new projects

Create a project in the Workspace. The git remote is configured automatically — no terminal commands required.

For existing repos

git remote add outerbot https://git.outer.bot/YOUR_USERNAME/YOUR_PROJECT.git
git push outerbot main

Your git remote URL is shown on the setup page after signing in.

Slash Commands

Type any slash command in the chat input — in the Workspace or any IDE using the outer.bot proxy. All commands are processed server-side, so they work identically everywhere.

Security & data handling

What outer.bot stores: if you connect a memrepo, your project briefing, learned facts, rejections, and skills live in that repo — outer.bot's database keeps a rebuildable cache of it, not a second copy of record. If you run in database mode instead, that same content lives directly in outer.bot's database. Either way, session summaries and usage metadata — which model you called, when, and how many tokens — stay server-side.

What outer.bot does not store: request and response bodies are not persisted. The content of what you send to a model and what it sends back passes through outer.bot's proxy but is not kept afterward.

Deleting a connected memrepo and reconnecting an empty one removes your briefing, learned facts, rejections, and skills from outer.bot's cache too. Deleting a project deletes its briefing and session summaries. Deleting your account deletes everything tied to it. Full detail: privacy.html.

API reference

outer.bot's proxy is a drop-in replacement for the Anthropic and OpenAI-compatible APIs — point your tool's base URL at it and requests pass through with your project's briefing injected automatically.

Chat completions

POST https://api.outer.bot/v2/{your-token}/v1/messages         # Anthropic format
POST https://api.outer.bot/v2/{your-token}/v1/chat/completions # OpenAI format

Same request/response shape as the underlying provider's API. Authenticate with either the token embedded in the URL (zero-config) or an Authorization: Bearer obt_… header against the base https://api.outer.bot/v2 URL.

Briefing

GET https://api.outer.bot/v2/outerbot/briefing/{projectId}
Authorization: Bearer obt_YOUR_TOKEN

Returns the current briefing for a project as JSON: { "briefing": "...", "lastUpdated": "..." }. briefing is null until outer.bot has recorded something for that project.