OB-1 is a multi-model coding agent for your terminal. This manual covers everything from first install to advanced workflows.

Why OB1?

OB1 is a terminal-based coding agent—like Claude Code, but with multi-model access and self-optimizing workflows. You bring your own API keys (or use ours), pick the best model for each task, and let OB1 handle the rest.

The short version: if you're locked into a single model provider, hitting context limits, or manually repeating the same workflows, OB1 fixes that.

• •300+ Models, One Interface: Claude (including Opus 4.6), GPT, Gemini, Grok, Qwen, MiniMax, Llama—plus fast inference via Cerebras and SambaNova. Switch with /model or let auto-routing pick the best one. No vendor lock-in.
• •Self-Optimizing Skills: OB1 learns from your sessions. Run /inbox to see suggested skills, hooks, and workflow optimizations tailored to how you work.
• •Session Forking & Time Travel: Fork any conversation to explore alternatives. Rewind to any point. Share sessions with teammates via link.
• •Claude Code Compatible: Migrate from Claude Code with /migrate. Your existing AGENTS.md, skills, and commands carry over.

Get Started

OB1 is in open beta. Request access to get started—most users are approved within 24 hours. Once approved, you'll receive setup instructions and can be up and running in minutes.

Using OB1

Yolo Mode

Press Ctrl+Y to toggle yolo mode—OB1's full autonomy mode. When enabled, OB1 executes all tools without asking for confirmation: file edits, shell commands, everything.

• Safe YOLO (default): Auto-approves safe tools, confirms dangerous ones
• Full YOLO (Ctrl+Y): Everything auto-approved, no interruptions
• Persists: Your approval mode carries across sessions—set it once and it sticks

Commands

OB1 includes slash commands for common workflows. Type / to see all available commands.

Core Commands

Session Management

Collaboration & Sharing

To clone a shared session: ob1 --clone <share-id>

Configuration

Tools & Extensions

Resources & Community

Images & Vision

Paste images directly into the prompt—screenshots, diagrams, error messages. OB1 can analyze them in context. Drag and drop also works on macOS.

• Paste from clipboard: Copy a screenshot and paste it into the prompt
• Drag and drop: Drag image files directly into the terminal
• File references: Mention image files with @screenshot.png and OB1 will analyze them

OB1 automatically routes images through a vision preprocessor to avoid context size issues with large images.

Auto Mode

Set your model to auto and OB1 picks the best model for each prompt. Simple questions go to fast models, complex tasks go to premium ones.

• Switch to auto: /model auto
• How it works: OB1 classifies prompt complexity in real-time, considers cache state and context size, then routes to the optimal model
• Cost-aware: Tracks cost, latency, and success rates per model to improve routing over time

Reasoning Effort

The /model dialog includes a reasoning effort selector. Adjust how much "thinking" the model does—higher effort means more thorough analysis but slower responses. This is especially useful for models with extended thinking capabilities (Claude, o-series).

Sandbox Mode

Run ob1 --sandbox to spin up an isolated cloud environment for execution. Useful for testing risky commands, running untrusted code, or working in a clean environment without affecting your local machine.

• Start sandbox: ob1 --sandbox
• Powered by: Modal for fast, isolated container spin-up
• Use cases: Testing destructive commands, running untrusted scripts, clean-room debugging

How to Prompt

For the best results, be explicit with what you want. Instead of "can you do X?", try "do X."

• Keep it short, keep it focused. Break large tasks into smaller sub-tasks.
• Don't make the model guess. If you know which files to look at, say so.
• If you want planning without code, say: "Only plan. Do NOT write code."
• Use AGENTS.md files to guide OB1 on build commands and conventions.

Press Ctrl+P to activate the prompt enhancer—OB1 rewrites your prompt for clarity and specificity before sending it to the model. Useful when you have a rough idea but want OB1 to refine the instructions.

AGENTS.md

OB1 looks in AGENTS.md files for guidance on codebase structure, build/test commands, and conventions.

Sessions & Forking

OB1 automatically saves your conversation history. You can reference previous sessions, fork from any point, and explore parallel approaches.

• Session history: Browse past sessions with /resume
• Forking: Use /fork to branch from any message and try alternate approaches
• Rewind: Use /rewind to go back to any point in the conversation
• Named sessions: Use /session name for easier identification

Session Info (Ctrl+I)

Press Ctrl+I to open the session info dialog—a real-time overview of your current working state.

The session info dialog shows:

• PR status: Current pull request state, CI checks, and review status
• Branch: Current git branch and worktree path
• Merge conflicts: Files with unresolved conflict markers
• Session metadata: Name, description, and creation time

Finding Threads

OB1 can search through your past threads to find relevant conversations. Search by keyword, file path, or task using the thread tool.

# Search threads in current project
{"action": "list", "search": "auth refactor"}

# Search across ALL projects
{"action": "list", "scope": "all", "search": "database migration"}

# Get full content of a specific thread
{"action": "get", "thread_id": "3"}

OB1 uses these threads to maintain context across sessions. When you reference a previous task, OB1 can pull in relevant history automatically.

Mentioning Files

Type @ to search for and mention files in your prompts. This gives OB1 direct context about which files you want to work with.

• File mentions: @src/components/Button.tsx includes the file in context
• Glob patterns: @src/**/*.test.ts mentions multiple files
• In AGENTS.md: Use @docs/style.md to always include referenced files

Queueing Messages

You can queue messages to be sent to the agent once it ends its turn, without interrupting its current work.

• Queue a message: Press Cmd+Shift+Enter (macOS) or Ctrl+Shift+Enter (Windows/Linux) to queue instead of send immediately
• Multiple queued messages: Queue as many follow-up instructions as needed

This is useful when you think of additional requirements while OB1 is still working, or when you want to chain multiple tasks.

Mid-turn Steering

You can type while OB1 is working to steer it mid-turn. OB1 will incorporate your new instructions without starting over. This is different from queueing—mid-turn steering modifies the current task in progress.

Shell Mode

Execute shell commands directly without leaving OB1. Type ! in an empty prompt to toggle shell mode.

• Toggle shell mode: Type ! in an empty prompt
• Run commands: Commands execute directly, output is added to context
• Focus toggle: Press Ctrl+F to switch between agent and shell input

Smart Autocomplete

After OB1 finishes a response, it suggests natural follow-up actions based on what just happened. These aren't generic slash commands—they're contextual next steps.

• Context-aware: Suggestions are based on what OB1 just did—"run the tests" after a code change, "create a PR" after committing
• Tab to accept: Press Tab to accept a suggestion, or just start typing to ignore it
• Learns from you: Suggestions improve as OB1 understands your workflow patterns

Sharing & Collaboration

Share your OB1 conversations with teammates or the community. Shared sessions can be viewed on the web and cloned to continue the work.

• Create share link: /chat share-link generates a web URL for your conversation
• Clone a session: ob1 --clone <share-id> starts a new session from a shared one
• Export to file: /chat share conversation.md exports to markdown or JSON

Git Worktrees

OB1 has a built-in /worktree command for managing git worktrees—isolated workstreams without branch switching overhead.

/worktree new auth-refactor    # Create worktree with branch
/worktree list                 # Show all active worktrees

Worktrees auto-track branches with Graphite when available. Each worktree gets its own working directory so you can have multiple features in progress without stashing or switching branches.

Enforce Worktree

Enable security.enforceWorktree in settings to prevent OB1 from writing files directly on your main branch. When enabled, OB1 will block file edits and require you to create a worktree first—protecting against accidental changes to shared branches.

// ~/.ob1/settings.json
{
  "security": {
    "enforceWorktree": true
  }
}

Chrome Profiles

Use /chrome to launch a Chrome browser with persistent cookies, sessions, and login state. OB1 manages Chrome profiles so your browser agent can interact with authenticated web apps.

• Persistent sessions: Login once and stay logged in—cookies and sessions persist across OB1 sessions
• Profile management: OB1 creates and manages dedicated Chrome profiles separate from your personal browser
• Browser automation: Combined with the browser agent, interact with any web application that requires authentication

/chrome               # Launch Chrome with default OB1 profile
/chrome --profile work  # Use a named profile

Keyboard Shortcuts

Quick reference for all keyboard shortcuts in OB1.

Tools & Subagents

Skills

Skills are packages of instructions that teach OB1 how to perform specific tasks. They auto-configure from your session history and codebase patterns.

Skill Discovery

Skills are auto-discovered from multiple locations:

• ~/.ob1/skills/ — Personal skills
• .agents/skills/ — Project-specific skills
• ~/.ob1/org-skills/ — Organization-wide skills

Use /skills to see all available skills.

Builtin Skills

OB1 ships with builtin skills like onboarding and vercel-cli. These are always available and cover common workflows out of the box.

Skill Frontmatter

Skills can specify a model field in their frontmatter to auto-switch the model when activated. For example, a skill for code review might specifymodel: claude-opus to ensure high-quality analysis.

---
name: code-review
model: claude-opus
description: In-depth code review with architectural analysis
---

# Code Review Skill
...

Custom Commands

Create custom TOML commands in .ob1/commands/ (project) or~/.ob1/commands/ (global). Use /commands reload to reload commands without restarting OB1.

Subagents

OB1 can spawn subagents for complex tasks that benefit from independent execution. Each subagent has its own context and tool access.

Handoffs

OB1's main agent can hand off tasks to specialized subagents. Each subagent runs independently with its own context. The main agent orchestrates, delegates, and collects results.

Built-in Subagents

Subagents are useful for:

• Multi-step tasks that can be broken into independent parts
• Parallel work across different code areas
• Keeping the main thread's context clean

Model Inheritance

Subagents inherit the model from your current tier, or you can override per-agent with /subagents set <agent> <model>.

Schema Validation

Subagents return structured results. If schema validation fails, OB1 falls back to raw text output gracefully.

Web Research

OB1's web agent uses a tree-search strategy with query complexity routing. Simple queries go directly, complex ones spawn parallel research threads. It automatically manages search breadth vs depth based on query type.

Model Tiers

OB1 uses a tier system to assign models to subagents and internal services. Each tier balances cost, speed, and capability differently.

Use /subagents to see your current tier's model assignments and override specific agents for the session.

/subagents                          # View current assignments
/subagents set explore gpt-5        # Override explore agent
/subagents reset                    # Clear all overrides

The Worker agent is a full-capability implementation agent with the same tools as the main agent. Use it for autonomous implementation tasks: writing code, editing files, running commands, and executing multi-step changes. OB1 can delegate complex tasks to worker agents while you continue with other work.

Inference Providers

OB1 routes through multiple inference providers for optimal speed and cost.

All third-party providers (Cerebras, SambaNova, Baseten) are proxied through OB1's backend—no need to manage separate API keys.

Browser Agent

OB1 has a built-in browser agent for interacting with web pages. It can take screenshots, click elements, fill forms, and extract data from websites.

• Screenshots: Capture full pages or specific elements
• Interactions: Click buttons, fill forms, navigate pages
• Data extraction: Scrape content, read tables, grab text
• Real sessions: Uses a Chrome profile with your cookies and sessions

Use cases:

• QA verification—check if a page looks right after changes
• Demo validation—verify UI flows work end-to-end
• UI testing—interact with web apps during development
• Data extraction—pull information from web pages

Parallel Execution

OB1 supports parallel tool execution and optimized search. Multiple agents can work simultaneously on different parts of a task, dramatically speeding up complex operations.

• Parallel tools: Independent tool calls execute concurrently
• Optimized search: File searches run in parallel across directories
• Background tasks: Delegate work to worker agents while continuing

Verifiers

Verifiers are post-completion quality gates. After OB1 finishes a task, verifiers automatically check that the work meets quality standards before considering it done.

Verifiers check things like:

• Build passes: Does the project still compile?
• Tests pass: Did any existing tests break?
• Lint clean: Does the code meet project standards?
• Type check: Are there any type errors?

Verifiers auto-discover commands from your AGENTS.md. They scan for build, test, and lint commands and run them automatically after task completion. No manual configuration needed—just document your commands in AGENTS.md and verifiers pick them up.

MCP Servers

Extend OB1 with additional tools using MCP (Model Context Protocol) servers. MCP tools integrate naturally into your workflow.

Adding via CLI

The fastest way to add an MCP server:

# SSE/HTTP transport (remote servers)
ob1 mcp add linear https://mcp.linear.app/sse --transport sse --scope user

# stdio transport (local servers)
ob1 mcp add filesystem npx -- -y @anthropic-ai/mcp-filesystem /path/to/dir --scope user

Manual Configuration

Add MCP servers to the mcpServers key in ~/.ob1/settings.json:

{
  "mcpServers": {
    "linear": {
      "url": "https://mcp.linear.app/sse"
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-filesystem", "/path/to/dir"]
    }
  }
}

After adding servers, run /mcp refresh inside OB1 to load them without restarting, or use /mcp list to see configured servers and their status.

Code Review

OB1 has built-in PR review capabilities via the pr-review-workflow skill. It auto-activates when you share a GitHub or Graphite PR URL.

Triggering Review

• Share a PR URL: https://github.com/org/repo/pull/123
• Ask to review: "review PR #123"
• Share a Graphite link: https://app.graphite.com/github/pr/...

Review Checklist

OB1 automatically evaluates PRs against:

• Scope check: Single logical change? Right size?
• Structure: Clear title, description explains WHY
• Security: No secrets, proper auth checks
• Conventions: Follows existing patterns

Multi-Round Reviews

OB1 supports iterative review cycles—structural issues first, then refinements, then edge cases and polish.

Configuration

OB1 can be configured through ~/.ob1/settings.json. All settings use the ob1. prefix.

Per-model System Prompts

Each model can have custom system prompt injections, thinking budgets, and behavioral overrides. OB1 automatically injects model identity information so the agent knows which model it's running as.

{
  "modelConfigs": {
    "anthropic/claude-opus-4": {
      "systemPromptPrefix": "You are a senior architect...",
      "thinkingBudget": 10000
    }
  }
}

Permissions

OB1 has a sophisticated permission system that controls which tools and commands can run without approval. Permissions use a priority-based rule system with three tiers: Admin > User > Default.

Approval Modes

Policy Decisions

Each tool invocation is checked against policy rules. A rule can result in:

• allow: Tool runs without prompting
• deny: Tool is blocked outright
• ask_user: User must confirm before tool runs

Built-in Allow List

These read-only tools are auto-approved by default:

glob, search_file_content, list_directory,
read_file, google_web_search

Folder Trust

Use /permissions trust [path] to manage which folders OB1 can operate in. Untrusted folders require additional confirmation.

Hooks

Hooks are shell scripts that OB1 runs at specific points in its workflow—before a tool executes, after the model responds, when a session starts, etc. Use them to inject context, enforce policies, or automate repetitive tasks.

Quick Start

Add hooks to ~/.ob1/settings.json (global) or .ob1/settings.json (project):

{
  "hooks": {
    "AfterTool": [
      {
        "matcher": "write_file|replace",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint --fix"
          }
        ]
      }
    ]
  }
}

This example runs npm run lint --fix every time OB1 writes or edits a file.

Hook Events

Writing a Hook Script

Hook scripts receive JSON on stdin and must output JSON to stdout. Use stderr for logging—anything else on stdout breaks parsing.

#!/usr/bin/env bash
# .ob1/hooks/block-secrets.sh
input=$(cat)

# Extract content being written
content=$(echo "$input" | jq -r '.tool_input.content // ""')

# Check for secrets
if echo "$content" | grep -qE 'api[_-]?key|password|secret'; then
  echo '{"decision": "deny", "reason": "Potential secret detected"}' 
  exit 0
fi

echo '{"decision": "allow"}'
exit 0

Then reference it in your settings:

{
  "hooks": {
    "BeforeTool": [
      {
        "matcher": "write_file|replace",
        "hooks": [
          {
            "type": "command",
            "command": ".ob1/hooks/block-secrets.sh"
          }
        ]
      }
    ]
  }
}

Matchers

The matcher field controls which tools trigger the hook. Use "*" for all tools, or a regex pattern like "write_file|replace" for specific ones.

Managing Hooks

• View hooks: /hooks panel
• Enable/disable: /hooks enable <name> or /hooks disable <name>
• Enable all: /hooks enable-all

Themes

OB1 supports terminal themes. Use /theme to switch between them.

• Built-in themes: Default dark, Solarized Dark, Solarized Light
• Custom themes: Can be defined in settings or bundled with extensions

Pricing

Early Access

OB1 is currently in early access. All features are available free during this period.

Check your usage with /stats.

Enterprise

For teams requiring SSO, advanced security, and dedicated support, contact team@openblocklabs.com.

Support

For help with OB1, join our Discord community or email team@openblocklabs.com.

To report bugs, use /bug in OB1—it automatically includes your session context.

Supported platforms: macOS, Linux, Windows (WSL recommended).