OuterBot Documentation

OuterBot 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 ide.outer.bot and sign in.
3. Create a project — Click +, enter a project name. OuterBot 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 right panel. Your project briefing is injected automatically on every message. Community users get 10 Haiku messages/day 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, Tandem Engine, and Field Test.

Plans & Pricing

Community (Free — Limited Time)

Community gives you full Workspace access with 10 Claude Haiku messages/day included at no cost. No API key or credit card required. The free AI tier is a limited-time offer with no hard end date — we’ll give users advance notice before any change.

• OuterBot Workspace (ide.outer.bot)
• 10 AI messages/day on Claude Haiku
• 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 — OuterBot 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 →

OuterBot Workspace

The Workspace at ide.outer.bot is a full browser-based development environment. No installation required. Works on any desktop browser, and on mobile for quick reviews and chat.

Interface Overview

• Left panel — File Explorer — browse your project’s file tree, open files
• Center — Monaco Editor — the same editor that powers VS Code, with syntax highlighting and IntelliSense
• Right panel — OuterBot Panel — tabs for AI Chat, Guardian Briefing, Git, and Field Test
• Header — project selector, model picker, account menu

AI Chat

The AI Chat tab in the OuterBot Panel gives you a full agent that can read files, edit code, run searches, and create commits — all within the browser.

• 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.
• Tool use — the agent can read files, edit them, search the codebase, and run git operations.
• Plan before acting — agent describes its plan and waits for approval before making changes (configurable).
• Stop button — interrupt the agent mid-task at any time.
• Model picker — switch between providers directly in the composer. Each completed message shows which model was used.
• Smart Routing badge (⚡) — shown when Obie routed a simple turn to a faster model automatically.
• Obie Active indicator — shows when Obie’s pre-pass has filtered and optimized the context for this turn.

GitHub Integration

When you open a GitHub-linked project in the Workspace:

1. The repository is cloned to the server automatically
2. The file tree loads from your actual repo files
3. You edit files in the Monaco editor
4. The Git panel lets you commit, push, and view diffs without leaving the browser
5. After each agent turn that changes files, a pull request is automatically created on GitHub

Projects

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

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

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

Obie Skills is a long-term memory system that learns from your sessions over time. After each AI turn, Obie extracts patterns — coding conventions, architectural decisions, recurring patterns, things to avoid — and stores them as skills. On future turns, relevant skills are injected automatically.

Skill tiers

• Project skills — learned from this specific project’s sessions. Automatically injected when you open that project.
• User skills — patterns that apply across all your projects (e.g., your preferred code style, frameworks you always use).
• Global skills — general best practices seeded by OuterBot (anti-overengineering, TypeScript patterns, etc.). Filtered by keyword relevance each turn.

How skills are extracted

After high-quality turns (Obie’s shadow scoring above 75), Obie reads the conversation and produces structured skill entries. These are stored in your project’s .outerbot/skills/ directory and merged into future sessions.

Fusion Mode

Fusion Mode is an opt-in mode for Pro users that dispatches your message to multiple models simultaneously and uses Obie (Haiku) to synthesize the strongest combined answer. You choose your pairing — the recommended preset is Sonnet 4.6 + DeepSeek V4 Pro.

Standard Fusion vs Deep Fusion

• Standard Fusion — 2 models in parallel: Sonnet 4.6 (always Model A) + your choice of Model B. Recommended pairing: DeepSeek V4 Pro via Together.ai.
• Deep Fusion — 3 models in parallel: Sonnet 4.6 + Model B + Model C. Best for high-stakes decisions where maximum coverage matters.

How it works

1. Enable Fusion in the toolbar, then click ⚙ to configure your pairing
2. All selected models receive the full context in parallel
3. Each model generates its response independently
4. Obie reads all responses and synthesizes the strongest combined answer
5. You receive the synthesized result

Choosing your pairing

Cross-provider pairings work best. Models from different companies have different training data and reasoning approaches, so their outputs diverge in useful ways. Same-provider pairings tend to agree and add less synthesis value.

• Recommended: Sonnet 4.6 + DeepSeek V4 Pro (Together.ai) — cross-provider, ~27% of frontier model cost, 100% benchmark pass rate
• Sonnet 4.6 + Llama 3.3 70B (Groq) — no Together.ai key needed, very fast
• Sonnet 4.6 + GPT-4.1-mini (OpenAI) — two strong generalist models

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

There are two ways to enable Tandem:

• Workspace toggle — click the Tandem button in the OuterBot Workspace chat toolbar. Applies to the current session only. Available to Pro users.
• Account default — go to Account Settings → AI Settings → Tandem Engine. Enable by default to run Tandem on every message from any IDE (Cursor, Windsurf, VS Code, etc.) automatically.

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 OuterBot’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 OuterBot Workspace
2. Click the Field Test tab in the OuterBot 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 — OuterBot adds $0. BYOK is required for Pro; without a key, the Pro plan will prompt you to add one before chatting.

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 OuterBot on GitHub (scopes: repo, read:user)
4. You’ll be redirected back with your GitHub username shown

AI Proxy Setup (Any IDE)

OuterBot’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 OuterBot, your project briefing is injected automatically on every message, even in your local IDE.

Your proxy URL is: https://api.outer.bot/v2/{your-token}/ — find it at outer.bot/setup after signing in.

Claude Code

Paste this into Claude Code and it will configure itself:

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

Cursor

Settings → Models → API Base URL → paste your proxy URL.

Windsurf

Settings → AI → Custom API endpoint → paste your proxy URL.

Any OpenAI-compatible SDK

import openai
client = openai.OpenAI(
    base_url="https://api.outer.bot/v2/YOUR_TOKEN/",
    api_key="your-provider-key"
)

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 OuterBot proxy. All commands are processed server-side, so they work identically everywhere.