SDK Feature Comparison

Agor integrates with multiple AI coding agents. Each SDK has different capabilities based on their native features and API design.

Feature Matrix

Legend:

• ✅ Full support - Feature works natively via SDK
• ⚠️ Limited - Partial support or workarounds needed
• 🟡 Emulated - Agor implements the feature
• ❌ Not supported - Not available

Detailed Feature Breakdown

1. Streaming Responses

Streaming support varies significantly between agents:

Claude Code: ✅ Full text + tool streaming

• Token-level text streaming via async generators (content_block_delta events)
• True real-time typewriter effect with minimal latency
• Tool execution events stream in real-time (tool_use start/complete)
• Supports stopping mid-stream

Codex: ⚠️ Tool event streaming only (no text streaming)

• Tool execution events stream in real-time via runStreamed() (item.started, item.completed)
• Text responses arrive all at once in item.completed for agent_message items — no partial text delivery
• The Codex SDK does not emit item.updated for text content (only for todo_list items)
• Agor displays text immediately when the complete event arrives, but there is no typewriter effect
• This is an upstream SDK limitation, not an Agor limitation

Gemini: ✅ Full text + tool streaming

• Token-level text streaming via sendMessageStream() (Content events)
• True real-time typewriter effect
• Tool call request/response events stream in real-time
• 13 distinct event types for rich progress feedback

Copilot: ✅ Full text + tool streaming

• Token-level text streaming via assistant.message_delta events with deltaContent
• True real-time typewriter effect
• Tool execution events stream via tool.execution_start / tool.execution_complete
• 40+ distinct event types for detailed progress feedback
• Uses event emitter pattern on CopilotSession + sendAndWait() blocking call

OpenCode: ✅ Full text + tool streaming

• Token-level text streaming via SSE event subscription (message.part.updated events)
• True real-time typewriter effect with reasoning block support
• Tool execution events stream with state transitions (pending → running → completed)
• Supports 75+ LLM providers (OpenAI, Anthropic, Google, and self-hosted models)

Agor Implementation: StreamingCallbacks interface provides unified streaming for all agents. Claude, Gemini, Copilot, and OpenCode get the full typewriter experience; Codex text appears instantly once the model finishes generating.

2. Stop Mid-Execution

Claude Code: ✅ Full support

• Native interrupt() method in Agent SDK
• Gracefully stops execution
• Returns partial results
• Safe cleanup of resources

Codex: ⚠️ Limited

• Can abort HTTP request
• May lose partial work
• Less graceful than Claude

Gemini: ⚠️ Limited

• Can abort stream
• May lose partial tool execution results
• Similar to Codex limitations

Copilot: ⚠️ Limited

• Can cancel via session abort
• May lose partial work from in-progress tool executions
• Similar to Codex/Gemini limitations

OpenCode: ⚠️ Limited

• Can abort via session abort API
• May lose partial work from in-progress tool executions
• Event stream disconnection triggers cleanup

3. Session Import/Export

Claude Code: ✅ Full support

• Sessions stored as JSONL transcript files in ~/.claude/projects/
• Rich metadata (git state, tool uses, timestamps)
• Agor can parse and replay transcripts
• Enables session portability

Codex: ❌ Not supported

• No native session persistence format
• Agor stores sessions in own database
• Cannot import external Codex sessions

Gemini: ❌ Not supported

• Has checkpoint system but format undocumented
• Agor stores sessions in own database
• Cannot import external Gemini sessions

Copilot: ❌ Not supported

• No native session export format
• Agor stores sessions in own database
• Cannot import external Copilot sessions

OpenCode: ❌ Not supported

• No native session export format
• Agor stores sessions in own database via sdk_session_id mapping
• Cannot import external OpenCode sessions

4. Session Forking

All agents support forking via Agor’s replay mechanism:

1. User requests fork at specific message
2. Agor creates new session
3. Replays messages up to fork point
4. New prompts diverge from original
5. Full genealogy tracking in database

Note: This is an Agor feature, not SDK-native. Works identically across all agents.

5. MCP Integration

Claude Code: ✅ Native support

• MCP servers configured in Agent SDK options
• Tools automatically exposed to Claude
• Supports MCP prompts, resources, and tools
• Agor UI for managing MCP server configs per session

Codex: ✅ Native support

• MCP servers configured via per-session config.toml under [mcp_servers.<name>]
• Supports both STDIO (command + args) and streamable HTTP (url + bearer_token_env_var) transports
• Agor’s built-in MCP server auto-configured for self-awareness (sessions, worktrees, boards, etc.)
• Session-level MCP selection via Agor UI, same as Claude and Gemini

Gemini: ✅ Native support

• MCP servers configured directly through the SDK config
• Supports advanced options (tool filtering, transport selection) shared with Claude
• Agor provides the same session-level MCP selection UI for Gemini sessions

Copilot: ✅ Native support

• MCP servers configured via SDK’s mcpServers option
• Supports streamable HTTP transport with session token authentication
• Agor’s built-in MCP server auto-configured with session token via query parameter
• Session-level MCP selection via Agor UI, same as other agents

OpenCode: ✅ Native support

• MCP servers added dynamically via REST API (mcp.add())
• Supports both local (STDIO) and remote (Streamable HTTP) transports
• Agor injects its built-in MCP server with session token authentication
• User-defined MCP servers injected per-session from Agor UI
• OpenCode tries Streamable HTTP first, then falls back to SSE for remote servers

See Architecture Guide: Agor as an MCP Server for details on using MCP with all agents.

6. Permission Requests

Claude Code: ✅ Rich permission system

• Granular tool-level permissions (Read, Write, Edit, Bash, etc.)
• Permission modes: 'ask', 'auto', 'allow-all'
• Tool-specific context (file paths, command previews)
• Diff previews for file edits
• Agor shows rich permission modals with previews

Codex: ⚠️ Basic permission modes

• Simpler permission system
• Modes: 'ask', 'auto', 'allow-all'
• Less granular than Claude

Gemini: ⚠️ Basic permission modes

• Similar to Codex
• Function calling requires explicit approval
• Less detailed context than Claude

Copilot: ✅ Interactive permission system

• onPermissionRequest callback receives typed PermissionRequest with kind:
  • shell — bash/terminal commands
  • write — file write operations
  • read — file read operations
  • mcp — MCP tool calls
  • url — URL access
  • custom-tool — custom tool invocations
• Permission modes: 'default' (prompt for all), 'acceptEdits' (auto-approve read/write), 'bypassPermissions' (auto-approve all)
• Agor shows interactive permission UI with approve/deny buttons
• No SDK-level persistence — the Copilot SDK (v0.2.0) does not expose a mechanism to save permission rules (unlike Claude’s updatedPermissions). Approvals are per-request only. The Copilot CLI itself supports persistent rules via ~/.copilot/config.json and --allow-tool flags, but these are not accessible through the SDK’s onPermissionRequest callback
• MCP tools from attached servers (including Agor’s built-in server) are auto-approved

OpenCode: ⚠️ Auto-granted by Agor

• OpenCode emits permission.asked events when tool execution requires approval
• Agor auto-grants all permissions (responds with 'always') to prevent session hangs
• Permissions include external_directory access when working outside the default project
• No interactive UI — designed for autonomous agent operation

Agor Implementation: Permission modals adapt based on agent type. Claude shows persistent scope options (Project/User/Local); Copilot shows approve/deny only. OpenCode permissions are auto-granted for seamless autonomous execution.

7. Project Instructions

Claude Code: ✅ CLAUDE.md auto-loading

• Agent SDK automatically loads CLAUDE.md from working directory
• Supports both project-level (.claude/) and personal (~/.claude/) instructions
• No manual injection needed
• Agor sessions inherit project instructions automatically

Codex: ✅ AGENTS.md auto-loading

• Codex automatically loads AGENTS.md from the working directory
• Agor generates a per-session AGENTS.md with project context at the worktree’s CODEX_HOME
• No manual injection needed

Gemini: ⚠️ Manual injection

• No standard instruction file format
• Agor can inject instructions via system prompt
• Requires explicit configuration

Copilot: ⚠️ Manual injection

• No standard instruction file convention
• Agor injects context via the system prompt and initial message
• Respects .github/copilot-instructions.md if present in repository

OpenCode: ✅ opencode.json auto-loading

• Reads project configuration from opencode.json in the working directory
• Supports custom instructions, model defaults, and provider configuration
• Directory-scoped operations ensure the correct project config is loaded
• Agor passes the worktree path to scope OpenCode to the correct project

Recommendation: Use Claude Code or Codex for projects with rich context requirements. OpenCode is ideal for teams using multiple LLM providers. For Gemini and Copilot, manage instructions in Agor session config.

8. Tool Execution & Visualization

Claude Code: ✅ Rich tool metadata

• Detailed tool use objects with id, name, input
• Tool result blocks with rich content types
• Supports rendering custom tool widgets (Todo lists, diffs, etc.)
• Agor can build sophisticated tool visualizations

Codex: ⚠️ Basic function calling

• OpenAI function calling format
• Less structured than Claude’s tools
• Agor normalizes to common format

Gemini: ⚠️ Basic function calling

• Google function calling format
• Similar to Codex in structure
• Agor normalizes to common format

Copilot: ✅ Rich event-based tool tracking

• 40+ event types provide detailed tool lifecycle information
• tool.execution_start / tool.execution_complete events with tool name and arguments
• File edit events, bash command events, and search events are all distinct
• Agor normalizes Copilot events to the common message format

Agor’s Tool Widgets:

• Todo lists - Rendered from Claude’s TodoWrite tool
• File diffs - Syntax-highlighted edits (Claude Write/Edit tools)
• Bash output - Terminal-style output rendering
• Permission requests - Interactive approval modals

OpenCode: ✅ Rich event-based tool tracking

• Tool parts include tool name, callID, and state with input/output
• State transitions: pending → running → completed with output
• Agor normalizes OpenCode tool parts to common tool_use / tool_result content blocks
• File edit events and bash commands are all tracked as tool parts

Works best with Claude Code due to richer tool metadata. OpenCode and Copilot’s event types provide a solid foundation for rich visualization.

9. Session Continuity

Claude Code: ✅ SDK-managed conversation

• Agent SDK assigns session_id for multi-turn conversations
• Agor captures and stores sdk_session_id
• Seamless continuity across multiple prompts
• No message replay needed

Codex: 🟡 History-based continuity

• No native session concept
• Agor passes message history array to each API call
• Seamless from user perspective, more work behind the scenes

Gemini: 🟡 History-based continuity

• Uses setHistory() to restore conversation state
• Similar to Codex pattern
• Works reliably but requires explicit history management

Copilot: ✅ SDK-managed conversation

• SDK assigns session ID for multi-turn conversations
• Agor captures and stores sdk_session_id from CopilotSession
• Seamless continuity via resumeSession() with fallback to createSession()
• No message replay needed

OpenCode: ✅ SDK-managed conversation

• SDK assigns session ID on creation
• Agor captures and stores sdk_session_id from OpenCode session
• Seamless continuity via session resume with the stored ID
• No message replay needed — OpenCode server maintains conversation state

Performance Consideration: Claude, Copilot, and OpenCode’s session ID approach scales better for very long conversations (no need to resend full history). Codex/Gemini history-based approach works fine for typical sessions.

10. Token Usage Tracking

Claude Code: ✅ Comprehensive token tracking

• Full extraction from SDK token_usage events
• Tracks: input_tokens, output_tokens, total_tokens
• Prompt caching metrics: cache_read_tokens, cache_creation_tokens
• Context window tracking via model_usage metadata
• Real-time usage display in Agor UI
• Historical usage analytics per session/task

Codex: ✅ Full tracking (input/output/cache)

• turn.completed events now emit usage payloads that Agor maps to TokenUsage
• Tracks: input_tokens, output_tokens, derived total_tokens
• Maps cached_input_tokens → cache_read_tokens for cost + context math
• Populates TaskHeader + Session footer pills with counts + $ estimate
• Feeds daemon cost calculator + context utilities automatically

Gemini: ❌ Not implemented

• Gemini API provides usage data but not yet extracted
• Future: Will track input/output token counts

Copilot: ⚠️ Via turn events

• Usage data available through turn.completed events
• Token counts can be extracted from SDK event metadata
• Not yet fully wired into Agor’s token tracking pipeline
• Future: Will populate TaskHeader pills and cost estimates

Why it matters:

• Cost tracking - Monitor API spending per session/project
• Performance optimization - Identify prompt caching opportunities (Claude)
• Context management - Track how close you are to context limits
• Analytics - Compare efficiency across different tasks

OpenCode: ✅ Via step-finish parts

• step-finish message parts include cost, tokens.input, tokens.output, tokens.reasoning
• Cache metrics: tokens.cache.read and tokens.cache.write
• Agor stores these in message metadata under opencode key
• Supports cost tracking across all 75+ providers

Agor Implementation: Token data stored in messages table, aggregated for session-level analytics. Claude, Codex, and OpenCode sessions display token/context pills today; Gemini and Copilot support is next.

11. Context Window Tracking

Claude Code: 🟡 Estimated (conversation size only)

• Tracks cumulative conversation tokens (input + output)
• Resets counter on compaction events
• Does NOT include system overhead (~46K tokens for CLAUDE.md + tools + MCP)
• Labeled as “Estimated” in UI to reflect limitations
• Shows 0-200K range accurately for conversation size

Codex: 🟡 Estimated (conversation + cache reads)

• Uses SDK input_tokens + cache_read_tokens per task
• Reuses Claude context-window utility for TaskHeader + footer pills
• Provides percentage vs. model-specific limit (gpt-5-codex, gpt-4o, etc.)
• Same limitations as Claude (system overhead not included)

Gemini: ❌ Not implemented

• No context tracking available yet

Copilot: 🟡 Estimated

• Uses same cumulative conversation token formula as Claude/Codex
• Model context limits vary by selected model (GPT-4o, Claude, etc. via Copilot)
• Same limitations as other agents (system overhead not included)

The Challenge:

Accurately tracking context window usage is surprisingly difficult because Anthropic doesn’t document which tokens count toward the 200K limit. Here’s what Agor does:

What we know:

• input_tokens - Fresh user prompt for this turn (definitely counts)
• output_tokens - Claude’s response (definitely counts)
• cache_read_tokens - Reading cached content (counts toward context but inflated by tool executions)
• cache_creation_tokens - Creating new cache entries (~46K baseline for CLAUDE.md + tools + MCP)

The problem with cache tokens:

• cache_read_tokens can be 10x inflated due to tool calls
  • Example: 38 tool calls × 40K cached system = 1.6M tokens reported (8x the 200K limit!)
  • This is a billing metric, not an accurate context measure
• cache_creation_tokens represents system overhead but grows unpredictably
  • First task: ~46K (CLAUDE.md + system prompt + tools)
  • Later tasks: Can grow to 100K+ as more content gets cached

Agor’s approach:

// Sum conversation tokens across all tasks
context_window = Σ(task.input_tokens + task.output_tokens);
 
// Reset on compaction events
if (compaction_detected) {
  context_window = 0; // Start fresh
}

What this gives you:

• ✅ Accurate tracking of conversation size (0-200K range)
• ✅ Proper accumulation across turns
• ✅ Automatic reset on compaction
• ❌ Excludes ~46K system overhead (CLAUDE.md, tools, MCP)

Example session:

Task 1:  8,956 tokens →  4.5% (conversation only)
Task 2: 10,593 tokens →  5.3% (growing)
Task 3: 13,540 tokens →  6.8%
Task 7: 23,546 tokens → 11.8%

Actual context: ~70K tokens (24K conversation + 46K system overhead)

Why “Estimated”:

Without official Anthropic documentation on the exact formula, we can’t be 100% certain our calculation matches their internal tracking. We’re confident in the conversation size tracking, but system overhead remains an educated guess.

Future: If Anthropic publishes official context window calculation docs, we’ll update our implementation immediately.

Advanced Claude Code SDK Features

Claude Code’s Agent SDK exposes several advanced features that Agor fully supports. These are Claude-exclusive and not available in Codex, Gemini, or Copilot integrations.

Task Tool & Nested Operations

What it is: The Task tool spawns subsessions (e.g., Explore, Plan agents) to handle complex multi-step operations autonomously.

Agor Implementation:

• Nested operation tracking - Captures parent_tool_use_id from SDK to link child operations (Read, Grep, etc.) to parent Task invocation
• Chronological grouping - Task nested blocks appear exactly where the parent Task was called, not at the bottom
• Collapsed by default - Shows summary (tool count, success/error stats) when collapsed
• Expandable inspection - Click to see full tool chain executed inside the subsession
• Purple visual treatment - Distinct styling to differentiate from regular tool chains

UI Display:

┌─────────────────────────────────────────────┐
│ ⚡ Explore · Find session settings modal    │
│ 3 tools · Read, Grep · ✓ 3                  │
│ Found SessionSettingsModal in src/...       │ [Collapsed]
└─────────────────────────────────────────────┘

When expanded:
  ├─ Read: src/components/SessionSettingsModal.tsx
  ├─ Grep: "Custom Context" in **/*.tsx
  └─ Read: src/pages/Settings.tsx

Database Storage: messages.parent_tool_use_id links all nested operations to their spawning Task tool use ID.

Extended Thinking Mode

What it is: Allocates additional tokens for Claude to use an internal “scratchpad” for reasoning through complex problems before generating responses.

Agor Implementation:

• Auto Mode (Default) - Detects keywords in prompts:
  • think → 4,000 tokens
  • think hard, think deeply → 10,000 tokens
  • think harder, ultrathink → 31,999 tokens
• Manual Mode - Set explicit budget (0-32k) in session settings
• Off Mode - Disable thinking to save costs
• Real-time streaming - Thinking blocks stream token-by-token via WebSocket (thinking:chunk events)

Example Prompts:

"think about the best architecture for this feature"
"think hard about potential edge cases before implementing"
"ultrathink this critical database migration strategy"

UI Display: Thinking blocks appear as separate content blocks in messages, visually distinct from response text. Rendered with gray background and ”🧠 Thinking…” header.

Cost Consideration: Extended thinking uses additional input tokens. Use judiciously for complex tasks where reasoning quality matters.

TodoWrite Tool & Sticky Display

What it is: Claude can create structured task lists to track progress during complex implementations.

Agor Implementation:

• Real-time updates - Todo status changes stream live via WebSocket
• Sticky display - Latest todo always visible at bottom of running task, above typing indicator
• Visual states:
  • ⏳ Pending - Not started yet
  • ⚙️ In Progress - Currently working (spinning icon)
  • ✅ Completed - Done
• Automatic cleanup - Completed todos collapse after a few seconds
• Historical view - All todos preserved in message history

UI Display:

Current Task:
┌─────────────────────────────────────────┐
│ ⚙️ Implementing database migration      │  ← Always visible
└─────────────────────────────────────────┘

[Typing indicator appears below]

Best Practice: TodoWrite tool activates automatically for multi-step tasks. Users can see exactly what Claude is working on in real-time.

Permission Scopes

What it is: Granular control over tool approvals with persistent scope levels.

Claude Code: ✅ Full persistent scopes

• Once - Approve this single tool execution
• Project - Save rule to .claude/settings.json (committed to repo)
• User - Save rule to ~/.claude/settings.json (global)
• Local - Save rule to .claude/.local/settings.json (gitignored)
• Uses SDK’s updatedPermissions mechanism to persist rules back to Claude

Copilot: ⚠️ Approve once only (beta)

• The Copilot SDK (v0.2.0) does not expose a updatedPermissions-equivalent mechanism
• The Copilot CLI natively supports persistent rules (~/.copilot/config.json, --allow-tool flags, and ! to allow-all-similar in interactive mode), but these are not accessible through the SDK callback
• Agor shows a simple Approve/Deny UI without scope options
• Future: When the SDK adds permission persistence support, Agor will wire it up

Codex / Gemini: ⚠️ Basic modes only

• Permission modes control auto-approval behavior, but no granular per-tool persistence

UI Display (Claude Code):

┌─────────────────────────────────────────────────┐
│ Claude wants to run: npm install               │
│                                                 │
│ ○ Allow once                                    │
│ ● Remember for this [Project ▼]                 │
│                                                 │
│ [Approve] [Deny]                                │
└─────────────────────────────────────────────────┘

UI Display (Copilot):

┌─────────────────────────────────────────────────┐
│ Copilot wants to run: npm install              │
│                                                 │
│ [Approve] [Deny]                                │
└─────────────────────────────────────────────────┘

Permission Modes (all agents):

• 'ask' / 'default' - Prompt for every tool use (default)
• 'auto' / 'acceptEdits' - Auto-approve safe operations, prompt for shell/mcp/url
• 'allow-all' / 'bypassPermissions' - Never prompt (use with caution)

Real-Time Tool Execution Indicators

What it is: Live feedback when tools are executing, before results are available.

Agor Implementation:

• WebSocket events - tool:executing events broadcast when tools start
• Visual indicators - Spinning icons next to tool names
• Multiple tools - Shows all concurrently executing tools
• Dismisses automatically - When tool results arrive

UI Display:

⚙️ Running tools:
  • Read src/components/TaskBlock.tsx
  • Grep "parent_tool_use_id" in **/*.ts

Why it matters: For long-running tools (Bash commands, large file reads), users see progress immediately instead of staring at typing indicator.

AgentChain Visualization

What it is: Groups consecutive tool-only messages into collapsed chains, hiding implementation details unless user wants to inspect.

Agor Implementation:

• Auto-grouping - 3+ consecutive messages with only tools/thinking → collapsed chain
• Summary display - Shows tool count and types when collapsed
• Expandable - Click to see full tool execution sequence
• Mixed messages - If assistant adds text response, chain breaks and text displays normally

UI Display:

┌─────────────────────────────────────────┐
│ 🔗 Agent Operations (5 tools)           │  [Collapsed]
│ Read, Edit, Bash, Grep, Write           │
└─────────────────────────────────────────┘

When expanded:
  ├─ Read: src/types/Message.ts
  ├─ Edit: Added parent_tool_use_id field
  ├─ Grep: "parent_tool_use_id" in **/*.ts
  ├─ Write: TaskNestedBlock.tsx (NEW)
  └─ Bash: pnpm build

Progressive disclosure: Users see high-level progress by default, can drill into details when debugging or learning.

Other Claude-Exclusive Features in Agor

Rich Tool Metadata:

• Detailed tool_use objects with ID, name, input parameters
• Tool result blocks with structured content types
• Enables sophisticated visualizations (file diffs, syntax highlighting)

Git State Tracking:

• SDK automatically captures branch, commit SHA, dirty state
• Displayed in task metadata pills
• No manual git querying needed

Session Import/Export:

• Parse Claude Code JSONL transcripts from ~/.claude/projects/
• Replay sessions in Agor
• Full fidelity preservation of tool uses, timestamps, git state

MCP Integration (all agents):

• First-class MCP server support across Claude Code, Codex, Gemini, and Copilot
• Session-level MCP server selection via Agor UI
• Agor’s built-in MCP server for self-awareness (sessions, worktrees, boards)
• Supports both STDIO and HTTP transports

Copilot-Specific Notes

Authentication

GitHub Copilot requires specific authentication:

• Fine-grained Personal Access Token (PAT) with the “Copilot Requests” account permission
• Classic PATs (ghp_...) are not supported by the Copilot API
• OAuth tokens from gh auth login also work
• Token is configured per-session in Agor’s session settings

SDK Status

The @github/copilot-sdk is currently in Technical Preview (v0.2.0). This means:

• API surface may change between versions
• Some features may be incomplete or experimental
• Agor’s integration will track SDK updates as they release

Model Selection

Copilot supports multiple underlying models selectable via the SDK:

• GPT-4o, GPT-4.1, Claude models, and others available through GitHub Copilot
• Model selection configured in Agor session settings
• Available models depend on your GitHub Copilot subscription tier

Choosing an Agent

Use Claude Code when:

• You need rich project instructions (CLAUDE.md)
• MCP server integration is required
• You want detailed tool execution visualization
• Session import/export is important
• You need the best permission request UX
• Token usage tracking and cost monitoring is important

Use Codex when:

• You prefer OpenAI’s models
• You need MCP integration (full STDIO + HTTP support, including Agor self-access)
• Basic permissions are sufficient
• You want token/cost/context pills powered by OpenAI usage data
• You have an AGENTS.md project instructions file
• Note: Text responses appear all at once (no typewriter streaming)

Use Gemini when:

• You prefer Google’s models
• Cost is a primary concern (Gemini pricing)
• Real-time text streaming is important (Gemini has full token-level streaming)
• You need MCP integration with Google’s SDK (full support via Agor UI)

Use Copilot when:

• You already have a GitHub Copilot subscription
• You want access to multiple model providers through a single API (GPT-4o, Claude, etc.)
• Real-time text streaming is important (full token-level streaming)
• You need MCP integration with GitHub’s SDK
• You prefer GitHub’s ecosystem and tooling

Use OpenCode when:

• You need support for 75+ LLM providers (OpenAI, Anthropic, Google, Mistral, self-hosted, etc.)
• You want to self-host or use your own API keys directly
• You’re running GitHub Copilot Pro+ through OpenCode for near-unlimited usage
• You prefer an open-source terminal-based agent
• You need flexibility to switch between providers without changing tools
• Cost optimization is important — bring your own keys, no middleman

OpenCode-Specific Notes

Architecture

OpenCode uses a client-server model unlike other agents:

• Server: opencode serve runs as a standalone process (user-managed, not started by Agor)
• SDK: @opencode-ai/sdk provides a REST client that communicates with the server
• Directory Scoping: Agor passes the worktree path via the x-opencode-directory header and directory query parameter to scope all operations

Provider Configuration

OpenCode supports 75+ providers configured via opencode auth login or environment variables:

• OpenAI (GPT-4o, GPT-5, etc.)
• Anthropic (Claude Sonnet, Opus, Haiku)
• Google (Gemini models)
• GitHub Copilot (via Pro+ subscription — near-unlimited usage)
• Self-hosted (Ollama, vLLM, etc.)
• Many more — any OpenAI-compatible endpoint

MCP Integration

OpenCode supports MCP servers via its REST API:

• Local (STDIO): Agor injects command + args configurations
• Remote (Streamable HTTP): Agor injects its built-in MCP server URL with session token
• OpenCode tries Streamable HTTP first, then falls back to SSE for remote connections
• MCP servers are added per-session and scoped to the worktree directory

Limitations

• Session forking not yet supported (OpenCode doesn’t provide fork/replay API)
• Session import/export not available
• Permissions are auto-granted by Agor (no interactive approval UI)
• Server must be running — opencode serve must be started separately before using in Agor

Future Improvements

As agent SDKs evolve, Agor will gain new capabilities.

See full roadmap on GitHub

Agent integration priorities:

• Codex text streaming - The Codex SDK (@openai/codex-sdk) does not support token-level text streaming as of v0.99.0. When OpenAI adds item.updated support for agent_message items (or a new text delta event), Agor’s code is already prepared to handle it
• Token tracking for Gemini & Copilot - Extract usage data from Google and GitHub APIs
• Gemini project files - If Google adds instruction file support
• Copilot project instructions - Track .github/copilot-instructions.md convention as it evolves
• Better stop controls - More graceful cancellation for all agents
• Richer tool metadata - If Codex/Gemini expose more tool details
• Copilot permission persistence - The Copilot SDK (v0.2.0) doesn’t expose a way to persist permission rules. When the SDK adds an updatedPermissions-equivalent, Agor will support persistent scopes (session, project, user) matching Claude Code’s UX
• OpenCode session forking - When OpenCode adds fork/replay API support
• OpenCode interactive permissions - Surface permission requests to Agor UI instead of auto-granting

Related Documentation

• Agent Integration Architecture
• Agor as an MCP Server
• MCP Tools Reference