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

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

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

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

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

Agor Implementation: Permission modals adapt based on agent type. Claude shows persistent scope options (Project/User/Local); Copilot shows approve/deny only. Both provide full interactive tool approval with parameter previews.

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

Recommendation: Use Claude Code or Codex for projects with rich context requirements. 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

Works best with Claude Code due to richer tool metadata. Copilot’s event types provide a solid foundation for future 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

Performance Consideration: Claude and Copilot’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

Agor Implementation: Token data stored in messages table, aggregated for session-level analytics. Claude and Codex 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

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

Related Documentation

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