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, GPT, Gemini, Grok, Llama—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 currently in early access. Join the waitlist for an invite—once approved, you'll receive setup and installation instructions.

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.

• On: OB1 moves fast, no interruptions
• Off: You approve each tool call before it runs
• 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

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

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.

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

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.

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

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.

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.

Skills live in ~/.ob1/skills/ (personal) or .agents/skills/ (project).

Subagents

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

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

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?

This catches issues before you even look at the output. Configure verifiers in your AGENTS.md by specifying your build and test commands.

MCP Servers

Extend OB1 with additional tools using MCP (Model Context Protocol) servers. Configure in ~/.ob1/mcp.json or bundle with skills.

{
  "linear": {
    "url": "https://mcp.linear.app/sse"
  }
}

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.

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

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).