SDK Feature Comparison

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

Cursor support is in beta: expect gaps and changes. Cursor sessions run autonomously (no approval prompts) and do not report token usage yet.

Codex subagent policy: Agor disables Codex’s native multi-agent feature for every Agor-launched Codex process with the per-process SDK override features.multi_agent=false. Agor does not edit ~/.codex/config.toml, and the override leaves unrelated user, project, model, and feature configuration intact. Use Agor sessions and subsessions for delegation so child work, genealogy, status, and callbacks remain observable. Agor’s version-aligned Codex package pins an SDK/CLI pair that supports this switch; an incompatible CLI configuration fails the Task rather than silently enabling native subagents.

For agent selection, start with Choosing an Agent. The reference below also covers integration behavior and SDK-specific limitations. Connection setup is covered separately in MCP Catalog & Connections.

Gemini Beta

Gemini is Beta and supports AI Studio API keys only. Add a key in Settings → Gemini. Google-account sign-in and Vertex AI are not supported.

• Accept edits (the default): auto-approves reads, edits and permitted MCP tools; shell, background processes and web access need Bypass permissions. A permitted MCP tool can request further work: for example, Agor’s session spawn tool can create a Bypass child when workspace policy permits it. Denying the parent’s built-in shell does not limit what an authorized child can do.
• Bypass permissions uses the SDK’s YOLO behavior for built-ins, shell, web, skills and loaded sub-agents. It is not a sandbox. Agor’s MCP selection and per-tool restrictions still apply.
• Manual approval, interactive questions and plan mode are unavailable. Existing Manual configurations fail when run; switch to Accept edits or Bypass. If a workspace manages your preset, ask an admin to change it.
• Built-in file edits can update build files inside the branch. MCP tools and sub-agents cannot edit build files. An agent declaring an MCP server name that clashes with an Agor-configured server cannot run. Two loaded agents declaring the same MCP server name share one merged server configuration in Bypass.
• Attachments and thinking display are not supported. Hooks and extensions are off.
• Follow-ups use SDK conversation recordings in the session’s SDK home, including across executors. If history cannot be restored, a notice explains the fresh start. If multiple recordings match one session, Gemini stops instead of choosing one. To preserve both and start fresh, set AGOR_GEMINI_RESET_HISTORY_FOR to the Agor session ID in your environment variables and retry once. The matching recordings move into a quarantine folder in the SDK home; remove the variable afterward.
• The executor’s per-task temporary directory (TMPDIR) lives in the SDK home unless a delegated launcher sets AGOR_EXECUTOR_SCRATCH_ROOT to an absolute local scratch directory, keeping it off a shared network home. Shell commands inherit it, so builds then share that scratch’s size limit. Conversation recordings always stay in the SDK home.
• MCP servers use the SDK’s 10-minute request timeout separately for each connection attempt, tool listing and tool call, so a server that accepts a connection and then stalls can hold up a turn for 10 minutes or more.
• The default model is gemini-3.8-flash. The picker also offers gemini-3.7-flash, gemini-3.5-flash-lite and the paid preview gemini-3.1-pro-preview. Stored 2.5 selections remain usable when the API key has access. Retired Flash selections are remapped with a notice; retired Pro selections require another model.
• Usage sums all model turns; context size reflects the last turn. Costs are estimates.

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
• Progress, compression and blocked-action notices

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)

Cursor (Beta): ✅ Text, thinking, and tool streaming

• Streams assistant, thinking, and tool_call events from the SDK’s run.stream()
• Text and thinking blocks arrive incrementally in the Agor UI
• Tool calls update in place as their status changes

Agor Implementation: StreamingCallbacks interface provides unified streaming for all agents. Claude, Gemini, Copilot, OpenCode, and Cursor 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: Task cancellation

• Stop aborts streams and running tools and marks the task stopped
• Follow-ups resume the SDK recording; side effects already performed are not rolled back

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

Cursor (Beta): ⚠️ Limited

• Stopping a task cancels the active Cursor run (Run.cancel())
• Text streamed before the stop is kept; in-progress tool work may be lost

3. Session Forking

Forking creates a sibling session that inherits the parent’s full conversation history at the fork point, then diverges. The mechanism is SDK-native where the agent supports it.

Claude Code: ✅ SDK-native fork

• On the fork’s first prompt, Agor sets resume: <parent_sdk_session_id> and forkSession: true on the Agent SDK query
• The SDK assigns a fresh session id derived from the parent’s history; subsequent prompts resume that id normally
• Atomic with the first prompt (no separate replay step)

Codex: ✅ App Server thread/fork

• The public @openai/codex-sdk does not expose fork(), but the local codex app-server does via the thread/fork JSON-RPC method
• On the fork’s first prompt, Agor spawns codex app-server as a short-lived sidecar, calls thread/fork with the parent’s thread id, and persists the returned thread id on the child session
• All subsequent prompts go through the normal SDK resumeThread(...).runStreamed(...) path. The sidecar is only touched once

Gemini, Copilot, OpenCode, Cursor: ❌ Not supported yet

• These SDKs don’t expose a fork primitive. Use spawn subsession to delegate a fresh-context child instead.

In every case Agor tracks genealogy.forked_from_session_id and fork_point_message_index in its own database so the UI can render the parent ↔ child relationship. The “Ask a side question” (btw) action is built on the same fork primitive and therefore lights up wherever fork is supported.

4. 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, branches, 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 the session token in the Authorization: Bearer header
• 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

Cursor (Beta): ✅ Native support

• MCP servers passed inline through the SDK’s mcpServers option
• Agor’s built-in MCP server injected over HTTP with the session token in the Authorization: Bearer header
• User-defined STDIO and HTTP servers injected per session from the Agor UI
• Cursor’s MCP config has no per-tool filter, so servers whose tools are gated are withheld from Cursor sessions, and Agor reports what was withheld

Remote MCP headers: For HTTP/SSE MCP servers that require service-account headers (for example DD-API-KEY), configure Custom HTTP Headers in Settings → MCP Servers. Header values can be literals or templates such as {{ user.env.DATADOG_API_KEY }}. Values are treated as secrets in UI/API responses, and Authorization is reserved for the Auth Type field so bearer/JWT/OAuth headers cannot be accidentally overridden.

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

5. 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: Accept edits and Bypass

See Gemini Beta for the permission boundary and limitations.

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: ✅ Interactive permission system

• OpenCode emits permission.asked events when tool execution requires approval
• Agor routes decisions through the same task-scoped permission service used by other agents
• Auto modes approve only their documented scope; question and nested task remain denied
• Permissions include external_directory access when working outside the default project

Cursor (Beta): ❌ Autonomous only

• The Cursor SDK does not expose a blocking permission callback Agor can route to the UI
• Cursor sessions run autonomously; the permission selector shows a single Autonomous mode
• Pair Cursor with sandbox execution mode when you need a filesystem boundary

Agor Implementation: Permission modals adapt based on agent type. Claude shows persistent scope options (Project/User/Local); Copilot and OpenCode use task-scoped approve/deny decisions.

6. 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: ✅ Native instructions injection

• Codex automatically loads AGENTS.md from the working directory and the user’s ~/.codex/
• Agor renders per-session project context to a temp file and passes it via the SDK’s model_instructions_file config, never mutating the user’s ~/.codex/ directory
• 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 branch path to scope OpenCode to the correct project

Cursor (Beta): ⚠️ Manual injection

• Runs locally with the branch worktree as its working directory
• Agor appends its session context to each prompt
• Cursor’s own project rule files are not yet documented as supported in Agor

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.

7. 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: Standard tool results

• Google function calls and results map to Agor tool blocks
• Reads, edits, shell and searches use the standard renderers
• Denials and tool errors remain visible in the transcript

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

Cursor (Beta): ✅ Rich event-based tool tracking

• tool_call events carry tool name, arguments, and status, and update in place
• Agor maps Cursor’s shell, read, write, edit, grep, glob, and todo tools onto the same renderers used for Claude (Bash, Edit, Write, TodoWrite), keeping the native tool name for reference

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

8. 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: ✅ SDK-managed thread

• Codex assigns a thread ID on the first prompt
• Agor stores it as sdk_session_id and resumes it with resumeThread() on every later prompt
• No message replay needed

Gemini: SDK-managed conversation recordings

• Restores the exact session recording through SDK resume
• Missing or ambiguous history continues fresh with a notice

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)

Cursor (Beta): ✅ SDK-managed conversation

• The Cursor SDK assigns an agent ID on the first prompt
• Agor stores it as sdk_session_id and resumes it with Agent.resume()
• No message replay needed

Gemini resumes its SDK recording rather than reconstructing history from rendered transcript messages.

9. 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: Per-turn usage

• Sums input, output and cache-read usage across model turns
• Uses the last turn for context size; costs are estimated

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

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

Cursor (Beta): ❌ Not available yet

• The Cursor SDK’s public types do not expose token counts or cost, so Cursor sessions show no token or cost pills
• Agor stores the raw run result for later extraction if usage data becomes available

Agor Implementation: Token data stored in messages table, aggregated for session-level analytics. Claude, Codex, and OpenCode sessions display token/context pills today; Gemini also records per-turn usage; Copilot support varies by event; Cursor reports none yet.

10. Context Window Tracking

Agor prefers the provider’s context-usage snapshot when one is available. Claude and Codex can report this directly; availability and fallback estimates depend on the integration and the data returned for that turn. Missing usage is not evidence that the context window is empty.

Use the meter to judge when to compact or start a focused session, not as a guarantee of remaining capacity. Cumulative token spend is not current context occupancy: repeated cached input can be billed across multiple tool calls. Cursor reports no usage yet, so its sessions have no meter.

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 the other agent 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

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

MCP Integration (all agents):

• First-class MCP server support across Claude Code, Codex, Gemini, Copilot, OpenCode, and Cursor
• Session-level MCP server selection via Agor UI
• Agor’s built-in MCP server for self-awareness (sessions, branches, 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
• 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)

Use Cursor (Beta) when:

• Your team already works in Cursor and wants its models and agent inside Agor
• Autonomous execution suits the work (Cursor sessions cannot ask for approval yet), ideally with sandbox execution mode
• You can live without token and cost tracking for now

OpenCode-Specific Notes

Architecture

OpenCode uses a client-server model unlike other agents:

• Server: Agor starts and contains a task-scoped opencode serve process
• SDK: @opencode-ai/sdk provides a REST client that communicates with the server
• Directory Scoping: Agor passes the branch path via the x-opencode-directory header and directory query parameter to scope all operations

Provider Configuration

OpenCode supports 75+ providers. Connect them in Settings → OpenCode Providers; Agor keeps native credentials in a tenant-and-user-scoped home and does not copy provider secrets into the executor environment.

• 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 the session token in an Authorization: Bearer header
• OpenCode tries Streamable HTTP first, then falls back to SSE for remote connections
• MCP servers are added per-session and scoped to the branch directory

Limitations

• Session forking not yet supported (OpenCode doesn’t provide fork/replay API)
• Supported deployments. Agor must be able to contain the native writer process safely: locally, or in hosted workspaces that meet the prerequisites below. Other multi-tenant, delegated, and templated-executor deployments report OpenCode as “not available” in settings, readiness, session creation, schedules, and prompts.
• Only the session owner can prompt. Shared prompting is disabled until credential identity is end-to-end consistent.

Hosted workspaces

Hosted workspaces run OpenCode by default when they meet the prerequisites in config.yaml, like this:

• Providers: every OpenCode provider that needs only an API key (more than 180, including Anthropic, OpenAI, Google Gemini, OpenRouter, xAI, Mistral, and DeepSeek). Save the key in Settings → OpenCode. Keys are encrypted for your account, only the selected provider’s key is delivered to your own executor run, and a key is verified by your first prompt. Providers that need OAuth sign-in, several credentials (Azure, Bedrock, Vertex), a custom endpoint, or a server on your own machine are not offered, and only models that support tool calls are listed.
• Sharing: on branches with a per-branch SDK home, OpenCode sessions follow the normal session sharing settings. With workspace and branch sharing on, teammates can prompt them, and each turn uses the prompting teammate’s own saved key for the session’s provider. Sessions kept in the owner’s home stay owner-only.
• Conversation state: each successful turn saves an immutable copy of OpenCode’s database, in the branch’s shared SDK home for shared sessions or your home (~/.agor/opencode/sessions/) otherwise, and the next turn resumes from the last completed one. A failed or stopped turn keeps the previous state. If saved state is missing or damaged, the turn fails rather than silently starting an empty conversation; start a new session to recover.
• Cleanup: superseded copies are removed during later turns of the same shared session, or during your later OpenCode turns. Copies from deleted shared sessions are not removed automatically. Removal is best-effort, not an erasure guarantee.

Cursor-Specific Notes (Beta)

Authentication

• Requires a Cursor API key (CURSOR_API_KEY), created in the Cursor dashboard’s integrations page
• Configured per user in Agor, like other agent keys

Runtime

• Uses @cursor/sdk with Cursor’s local runtime; the branch worktree is the working directory, and a session needs a branch
• Cursor’s config directory cannot be relocated per user yet (an upstream limitation), so per-user config isolation is not available for Cursor

Limitations

• No approval prompts: sessions run autonomously
• No token or cost tracking: the SDK does not expose usage data
• No session forking: use spawn subsession to delegate instead

Related Documentation

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