mdcontext 0.0.1 → 0.2.0

package/research/llm-summarization/agent-cli-tools-2026.md

@@ -0,0 +1,1082 @@
+# Agent CLI Tools for Code Summarization - 2026 Research
+
+## Executive Summary
+
+This document provides a comprehensive analysis of agent CLI tools available in 2026 for code summarization and analysis. The landscape has evolved significantly with the introduction of specialized agents, parallel execution capabilities, and standardized integration protocols like MCP (Model Context Protocol).
+
+**Top Tools for Code Summarization:**
+1. **Claude Code** - Most advanced autonomous coding agent with session summarization
+2. **GitHub Copilot CLI** - Specialized Explore agent for fast codebase analysis
+3. **Kiro CLI** - Best automatic conversation summarization at 80% context threshold
+4. **Aider** - Git-first approach with repository mapping and commit summarization
+5. **OpenCode** - Privacy-focused with 70+ AI model support and LSP integration
+6. **Cline** - Background daemon mode with gRPC API for parallel agent management
+
+---
+
+## 1. Claude Code CLI
+
+### Overview
+Claude Code is Anthropic's official agentic coding tool that lives in your terminal, providing autonomous code understanding, generation, and modification capabilities.
+
+### Installation
+
+**NPM Installation (Recommended):**
+```bash
+npm install -g @anthropic-ai/claude-code
+```
+
+**Requirements:**
+- Node.js 18+
+- Claude Pro subscription ($20/month) or API credits
+
+### Code Summarization Capabilities
+
+**Session Summarization:**
+- Generates automatic session summary at the end of each session
+- Shows detailed activity log of all changes and actions
+- Maintains context across long conversations
+
+**Codebase Understanding:**
+- Explores codebase context and answers questions
+- LSP (Language Server Protocol) integration for definition jumping and reference search
+- MCP (Model Context Protocol) support for external tool integration
+
+**Parallel Sub-Agent Execution:**
+- Multiple agents can work simultaneously on different aspects
+- Checkpoint features for long-running autonomous work
+- Since Claude Sonnet 4.5 (September 2025), parallel execution capabilities strengthened
+
+### Recent Updates (2026)
+
+**Version 2.1.0 (January 2026):**
+- Hooks for agents, skills, and slash commands (PreToolUse, PostToolUse, Stop)
+- Hot reload for skills - new skills available immediately without restart
+- Real-time thinking block display in Ctrl+O transcript mode
+- Syntax highlighting (added in 2.0.71)
+- `/plan` command shortcut for direct plan mode access
+- Slash command autocomplete works anywhere in input
+
+### Programmatic Integration
+
+**Claude Agent SDK:**
+Available in both Python and TypeScript for programmatic access.
+
+**Python Example:**
+```python
+import anyio
+from claude_agent_sdk import query
+
+async def main():
+    async for message in query(prompt="Summarize this codebase"):
+        print(message)
+
+anyio.run(main)
+```
+
+**TypeScript Installation:**
+```bash
+npm install @anthropic-ai/claude-agent-sdk
+```
+
+**Stdin/Stdout Communication:**
+- SDK spawns Claude Code CLI as subprocess
+- Communication via JSON messages over stdin/stdout
+- SDK writes JSON to CLI's stdin, reads responses from stdout
+
+**Current Limitation:**
+Claude Code uses the Ink library for terminal UI, which treats programmatic stdin differently than physical keyboard input. Physical Enter triggers `onSubmit`, but programmatic `\r` or `\n` is treated as newline without submission.
+
+**Workaround:**
+Use SDK mode (`@anthropic-ai/claude-agent-sdk`) for programmatic control with output streaming directly to stdout/stderr.
+
+### Pricing
+
+**Subscription Plans:**
+- **Pro:** $20/month ($17 with annual billing)
+- **Max 5x:** $100/month
+- **Max 20x:** $200/month
+
+**API Pricing:**
+- Claude Sonnet 4.5: $3.00 input / $15.00 output per 1M tokens
+- Prompts >200K tokens: $6.00 input / $22.50 output per 1M tokens
+- Batch API: 50% savings for bulk operations
+- Cached tokens: 90% discount (game-changer for agentic workflows)
+
+**Cost Analysis:**
+- Average usage: $6/day per developer
+- Heavy usage (90th percentile): $12/day
+- Monthly estimate: $100-200 for most users
+
+**Subscription vs API:**
+- Pro subscription includes $150 worth of API usage equivalent
+- API provides better cost control for heavy users
+- API has no usage limits for scaling
+
+### Model Support
+- Claude Opus 4.5
+- Claude Sonnet 4.5
+- Claude Haiku 4.5
+- Enterprise: Amazon Bedrock or Google Cloud Vertex AI instances
+
+### Sources
+- [CLI reference - Claude Code Docs](https://code.claude.com/docs/en/cli-reference)
+- [Claude Code - AI coding agent for terminal & IDE](https://claude.com/product/claude-code)
+- [Run Claude Code programmatically - Claude Code Docs](https://code.claude.com/docs/en/headless)
+- [Inside the Claude Agent SDK: From stdin/stdout Communication to Production on AWS AgentCore](https://buildwithaws.substack.com/p/inside-the-claude-agent-sdk-from)
+- [Claude Code Pricing | ClaudeLog](https://claudelog.com/claude-code-pricing/)
+- [Agent SDK overview - Claude API Docs](https://platform.claude.com/docs/en/agent-sdk/overview)
+
+---
+
+## 2. GitHub Copilot CLI
+
+### Overview
+GitHub Copilot CLI brings the power of Copilot coding agent directly to the terminal with specialized agents for different development tasks.
+
+### Installation
+
+Included with GitHub Copilot subscription - no separate installation required.
+
+**Requirements:**
+- GitHub Copilot subscription (Pro, Pro+, Business, or Enterprise)
+- Uses premium requests from your plan allowance
+
+### Code Summarization Capabilities
+
+**Specialized Agents (January 2026):**
+
+**Explore Agent:**
+- Fast codebase analysis without cluttering main context
+- Ask questions about code structure and relationships
+- Separate conversation context from main development work
+
+**Code-Review Agent:**
+- Evaluates modifications with focus on genuine issues
+- Reduces noise in review feedback
+- Runs in parallel with other agents
+
+**Plan Agent:**
+- Creates implementation plans for complex changes
+- Breaks down multi-step tasks
+
+**Parallel Execution:**
+- Multiple agents execute concurrently
+- Complex tasks (e.g., debugging authentication) reduced from 90s sequential to 30s parallel
+- Transforms workflow efficiency significantly
+
+### Context Management
+
+**Auto-Compaction:**
+- Automatically compresses history at 95% token limit
+- Prevents context overflow
+- Maintains conversation continuity
+
+**Persistent Codebase Memory:**
+- Available for Pro/Pro+ users
+- Retains understanding across sessions
+- Improves long-term project work
+
+### Programmatic Integration
+
+**Copilot SDK (Technical Preview - January 2026):**
+
+Available in four languages:
+- **Node.js/TypeScript:** `@github/copilot-cli-sdk`
+- **Python:** `copilot`
+- **Go:** `github.com/github/copilot-cli-sdk-go`
+- **.NET:** `GitHub.Copilot.SDK`
+
+**Features:**
+- Multi-turn conversations
+- Custom tool execution
+- Full lifecycle control for client and session management
+- Same engine as Copilot CLI - production-tested agent runtime
+
+**Usage:**
+- Programmatic access to GitHub Copilot CLI capabilities
+- Invoke agent runtime directly from code
+- Build custom integrations and workflows
+
+### Pricing
+
+**Subscription Tiers:**
+- **Free:** $0 (limited features)
+- **Pro:** $10/month
+- **Pro+:** $39/month
+- **Business:** $19/user/month
+- **Enterprise:** $39/user/month
+
+**Cost Model:**
+- CLI access included with subscription
+- No separate billing or API keys
+- Each interaction uses premium request allowance
+- Usage varies by feature/model
+
+### General Capabilities
+- Legacy codebase navigation
+- Cross-platform development setup
+- Multi-step implementations
+- Integrated with GitHub ecosystem
+
+### Sources
+- [GitHub Copilot CLI: Enhanced agents, context management, and new ways to install](https://github.blog/changelog/2026-01-14-github-copilot-cli-enhanced-agents-context-management-and-new-ways-to-install/)
+- [GitHub Copilot CLI](https://github.com/features/copilot/cli)
+- [Copilot SDK in technical preview](https://github.blog/changelog/2026-01-14-copilot-sdk-in-technical-preview/)
+- [GitHub - github/copilot-sdk](https://github.com/github/copilot-sdk)
+- [Plans for GitHub Copilot - GitHub Docs](https://docs.github.com/en/copilot/get-started/plans)
+
+---
+
+## 3. Kiro CLI
+
+### Overview
+Kiro CLI achieved the highest accuracy in 2026 benchmarks with 77% success rate, excelling in orchestrating interactive elements and complex component logic.
+
+### Code Summarization Capabilities
+
+**Automatic Conversation Summarization:**
+- Triggers at 80% of model's context window limit
+- Automatically summarizes all messages to reduce context length
+- Brings usage back below limit seamlessly
+
+**Context Usage Meter:**
+- Visual indicator in chat panel
+- Shows percentage of context limit used
+- Color-coded warnings (experimental feature)
+
+**Code Intelligence Features:**
+- LSP integration for go-to-definition
+- Find references across codebase
+- Hover information and diagnostics
+- Subagents extend context windows without summarization
+
+### Experimental Features
+- Context window usage percentage display in chat prompt
+- Color-coded context indicators
+- Advanced context management
+
+### Summarization Strategy
+Kiro's approach differs from other tools by automatically managing context at the 80% threshold, preventing manual intervention and maintaining conversation flow.
+
+### Sources
+- [Summarization - IDE - Docs - Kiro](https://kiro.dev/docs/chat/summarization/)
+- [Code Intelligence - CLI - Docs - Kiro](https://kiro.dev/docs/cli/code-intelligence/)
+- [Powers, Auto Summarization and Slash Commands - IDE - Kiro](https://kiro.dev/changelog/powers-auto-summarization-and-slash-commands/)
+- [Agentic CLI Tools Compared: Claude Code vs Cline vs Aider](https://research.aimultiple.com/agentic-cli/)
+
+---
+
+## 4. Aider
+
+### Overview
+Aider is a Git-first CLI coding agent designed for developers who live inside version control, with strong focus on repository-wide changes.
+
+### Installation
+
+```bash
+pip install aider-chat
+```
+
+### Code Summarization Capabilities
+
+**Repository Mapping:**
+- Builds comprehensive map of entire codebase
+- Uses Tree-sitter for better code understanding
+- Improved kebab-case identifier recognition
+- Enables work on larger projects effectively
+
+**Commit Message Summarization:**
+- Automatically generates sensible commit messages
+- Uses `--weak-model` option for commit message generation
+- Chat history summarization with optimized performance
+- Clear, descriptive messages for coordinated multi-file changes
+
+**Context Management:**
+- Repository map helps summarize large codebases
+- Works well for refactoring across multiple files
+- Feature updates that touch many files simultaneously
+
+### Key Strengths
+- Excellent for version-controlled projects
+- Strong at coordinated multi-file changes
+- Auto-commits with clear messages
+- Repository-wide understanding
+
+### Limitations (2026 Benchmarks)
+- Successful at basic structures
+- Deficiencies in detailed functional requirements
+- Complex form validations challenging
+- Multi-layered navigation menus less reliable
+
+### Sources
+- [Aider - AI Pair Programming in Your Terminal](https://aider.chat/)
+- [Release history | aider](https://aider.chat/HISTORY.html)
+- [Top 5 CLI Coding Agents in 2026 - DEV Community](https://dev.to/lightningdev123/top-5-cli-coding-agents-in-2026-3pia)
+- [Best AI Tools for Coding in 2026: 6 Tools Worth Your Time](https://www.pragmaticcoders.com/resources/ai-developer-tools)
+
+---
+
+## 5. OpenCode
+
+### Overview
+OpenCode is a privacy-focused, Go-based CLI application with support for 70+ AI models across multiple providers.
+
+### Installation
+
+Available as native CLI application (Go-based).
+
+### Code Summarization Capabilities
+
+**Automatic Prompt Summarization:**
+- Built-in feature in CLI interface
+- Maintains conversation context efficiently
+- Prevents context window overflow
+
+**Agent System:**
+
+**Build Agent:**
+- Default primary agent with all tools enabled
+- Full access to file operations and system commands
+- Standard development work agent
+
+**Plan Agent:**
+- Restricted agent for planning and analysis only
+- Analyzes code and suggests changes
+- Creates plans without modifying codebase
+- Perfect for code review and summarization tasks
+
+### Multi-Provider Support
+- **Providers:** OpenAI, Anthropic Claude, Google Gemini, AWS Bedrock, Groq, Azure OpenAI, OpenRouter
+- **Models:** 70+ AI models available
+- **Flexibility:** Switch between providers for optimal cost/performance
+
+### Integration Features
+
+**LSP Integration:**
+- Language Server Protocol support
+- Code intelligence features
+- Definition lookup and references
+
+**Tool Integration:**
+- Execute commands
+- Search files
+- Modify code programmatically
+
+**Session Management:**
+- SQLite database for persistent storage
+- Save and manage multiple conversation sessions
+- Long-term context retention
+
+### Non-Interactive Mode
+
+Run OpenCode for scripting and automation:
+```bash
+opencode "Summarize the authentication module"
+```
+
+Useful for:
+- Automation workflows
+- CI/CD integration
+- Quick queries without full TUI
+
+### Custom Commands
+- Create predefined prompts as Markdown files
+- Quick access to common summarization tasks
+- Workflow automation
+
+### Privacy & Flexibility
+- Freedom from vendor lock-in
+- Local session storage
+- Choose any AI provider
+- Full control over data
+
+### Interface Options
+- **CLI:** Advanced users with automatic summarization and customizable themes
+- **Desktop App:** Beginners or those preferring visual interface
+
+### Sources
+- [CLI | OpenCode](https://opencode.ai/docs/cli/)
+- [GitHub - opencode-ai/opencode](https://github.com/opencode-ai/opencode)
+- [Agents | OpenCode](https://opencode.ai/docs/agents/)
+- [OpenCode : Code 40x Faster with a Privacy-Focused AI Agent](https://www.geeky-gadgets.com/opencode-workflow-2026/)
+
+---
+
+## 6. Cline
+
+### Overview
+Cline is an autonomous coding agent with unique background daemon capabilities via gRPC API architecture.
+
+### Installation
+
+Available as CLI tool with Core-based architecture.
+
+### Daemon Mode & Background Processes
+
+**Cline Core Architecture:**
+- Runs as simple Node.js process
+- Exposes gRPC API for integration
+- Independent agent processes run in background
+- Can integrate into any application
+
+**Instance Management:**
+
+**Create and Manage Background Instances:**
+```bash
+# Start new instance and make it default
+cline instance new --default
+
+# List all running instances
+cline instance list
+
+# Kill specific instance
+cline instance kill localhost:50052
+
+# Kill all CLI instances
+cline instance kill --all-cli
+```
+
+**Port Architecture:**
+Each instance uses two consecutive ports:
+- **Core Service:** Port 50051+ (task operations)
+- **Host Bridge Service:** Port 50052+ (platform-specific operations)
+
+**Parallel Agent Management:**
+- Manage many agents running in parallel
+- Full scriptability for automation
+- Convenient chat interface
+- Independent instances with own port pairs
+
+### gRPC Communication
+
+**Protocol:**
+- CLI communicates via gRPC
+- Persistent background processes
+- Can be managed, monitored, and controlled independently
+- Suitable for long-running tasks
+
+### Use Cases for Daemon Mode
+- Multiple concurrent projects
+- Background code analysis
+- Persistent monitoring tasks
+- Scalable agent orchestration
+- Integration with larger systems
+
+### Sources
+- [GitHub - cline/cline](https://github.com/cline/cline)
+- [CLI Reference - Cline](https://docs.cline.bot/cline-cli/cli-reference)
+- [Cline CLI & My Undying Love of Cline Core - Cline Blog](https://cline.bot/blog/cline-cli-my-undying-love-of-cline-core)
+
+---
+
+## 7. Gemini CLI
+
+### Overview
+Google's open-source AI agent that brings Gemini directly into the terminal with advanced reasoning and natural-language coding.
+
+### Installation
+
+Available through Google's Gemini Code Assist.
+
+### Code Analysis Features
+
+**Endor Labs Extension:**
+- Code analysis using natural language
+- Vulnerability scanning
+- Dependency checks
+- Security analysis
+
+**Code Review Extension:**
+- Pre-packaged prompts for code review
+- Security analysis integration
+- External tool connections via MCP
+
+**ReAct Loop:**
+- Reason and Act loop architecture
+- Built-in tools for complex use cases
+- Bug fixing capabilities
+- Feature creation and test coverage improvement
+
+### Built-in Tools
+- Google Search grounding
+- File operations
+- Shell commands
+- Web fetching
+
+### MCP Support
+- Model Context Protocol integration
+- Custom extensions
+- Extensible architecture
+
+### 2026 Capabilities
+- Advanced reasoning
+- Enhanced tool usage
+- Natural-language coding in terminal
+- Generate, fix, and refactor without context switching
+
+### Limitations
+No specific daemon mode documented in 2026 sources.
+
+### Sources
+- [Gemini CLI | Gemini Code Assist](https://developers.google.com/gemini-code-assist/docs/gemini-cli)
+- [GitHub - google-gemini/gemini-cli](https://github.com/google-gemini/gemini-cli)
+- [Code Review and Security Analysis with Gemini CLI with Extensions](https://codelabs.developers.google.com/gemini-cli-code-analysis)
+- [Build, debug & deploy with AI | Gemini CLI](https://geminicli.com/)
+
+---
+
+## Background/Daemon Mode Capabilities Summary
+
+### Tools with Daemon Support
+
+| Tool | Daemon Mode | Architecture | Communication |
+|------|-------------|--------------|---------------|
+| **Cline** | ✅ Full | gRPC API | Port-based |
+| **Claude Code** | ⚠️ SDK | Subprocess | stdin/stdout |
+| **OpenCode** | ⚠️ Non-interactive | CLI args | Single execution |
+| **GitHub Copilot** | ❌ No | Session-based | SDK API |
+| **Aider** | ❌ No | Interactive | Terminal |
+| **Kiro** | ❌ No | Interactive | Terminal |
+| **Gemini CLI** | ❌ No | Interactive | Terminal |
+
+### Daemon Mode Architecture Patterns
+
+**1. Persistent Background Service (Cline):**
+- Agent runs as long-lived process
+- gRPC API for control
+- Multiple parallel instances
+- Port-based communication
+
+**2. Subprocess Model (Claude Code SDK):**
+- SDK spawns CLI as subprocess
+- JSON over stdin/stdout
+- Programmatic control
+- Limited interactivity
+
+**3. Non-Interactive Mode (OpenCode):**
+- Single execution from CLI args
+- No persistent state
+- Good for scripting
+- Quick queries
+
+**4. Session-Based SDK (GitHub Copilot):**
+- SDK manages sessions
+- Multi-turn conversations
+- Programmatic API
+- Not true daemon
+
+---
+
+## Stdin/Stdout Communication Patterns
+
+### Standard Communication Channels
+
+**Three Critical Channels:**
+1. **stdin:** Standard input for receiving commands
+2. **stdout:** Standard output for results
+3. **stderr:** Standard error for error messages
+
+### JSON Message Pattern (Claude Code SDK)
+
+**Write to stdin:**
+```json
+{
+  "type": "query",
+  "prompt": "Summarize this function",
+  "options": {}
+}
+```
+
+**Read from stdout:**
+```json
+{
+  "type": "response",
+  "content": "This function implements...",
+  "metadata": {}
+}
+```
+
+### Best Practices
+
+**Automation-Friendly CLIs:**
+- Explicit `--no-prompt` or `--no-interactive` flags
+- Disable stdin reads for deterministic behavior
+- Discoverable through `--help` text
+- No confirmation prompts in automation mode
+
+**Process Management:**
+- Spawn as subprocess with piped stdin/stdout/stderr
+- Clear separation of control logic and execution
+- SDK handles control, CLI handles execution
+- Python/TypeScript SDK manages callbacks and hooks
+
+### MCP Server Communication
+
+**Local Process Model:**
+- MCP servers run as local process
+- No data sharing between processes
+- Interact via stdin/stdout
+- Simple and local architecture
+
+### Agent Orchestration Patterns
+
+**Isolated Sessions:**
+- Each agent in isolated tmux session
+- Context separation
+- MCP servers enable communication
+- Both coordination and parallel processing
+
+**Daemon Patterns:**
+- Run as persistent background service
+- Listen continuously (e.g., microphone transcription)
+- Auto-spawn when needed
+- Unix socket for client communication
+
+---
+
+## Model Context Protocol (MCP) Integration
+
+### Overview
+MCP is an open standard introduced by Anthropic (November 2024) to standardize how AI systems integrate with external tools, systems, and data sources.
+
+### 2026: Year of Enterprise Adoption
+
+**Major Milestones:**
+- Transition from experimentation to enterprise-wide adoption
+- Major AI vendors standardized around MCP in 2025
+- Default integration protocol for enterprise AI
+- Move from pilot projects to production deployments
+
+### Governance
+
+**Agentic AI Foundation (December 2025):**
+- Anthropic donated MCP to AAIF
+- Directed fund under Linux Foundation
+- Co-founded by Anthropic, Block, and OpenAI
+- Open governance with transparent standards
+
+### Major Adoptions
+- OpenAI
+- Google DeepMind
+- Zed
+- Sourcegraph
+- Red Hat (OpenShift AI integration)
+
+### Use Cases
+
+**Agent Automation:**
+- Automate entire workflows, not just single tasks
+- Pull latest insights from on-premises databases
+- Access tools in different clouds
+- Connect distributed agents for collaboration
+
+**Integration Capabilities:**
+- Figma
+- Jira
+- GitHub
+- Custom enterprise systems
+
+### Security Considerations (April 2025 Analysis)
+
+**Outstanding Issues:**
+- Prompt injection vulnerabilities
+- Tool permissions - combining tools can exfiltrate files
+- Lookalike tools can silently replace trusted ones
+- Ongoing security research and improvements
+
+### Tools with MCP Support
+- Claude Code (native)
+- GitHub Copilot CLI
+- Gemini CLI
+- OpenCode
+- Most modern agent CLI tools
+
+### Sources
+- [Introducing the Model Context Protocol](https://www.anthropic.com/news/model-context-protocol)
+- [Building effective AI agents with Model Context Protocol (MCP)](https://developers.redhat.com/articles/2026/01/08/building-effective-ai-agents-mcp)
+- [2026: The Year for Enterprise-Ready MCP Adoption](https://www.cdata.com/blog/2026-year-enterprise-ready-mcp-adoption)
+- [Specification - Model Context Protocol](https://modelcontextprotocol.io/specification/2025-11-25)
+
+---
+
+## Comparison Matrix: Code Summarization Features
+
+| Feature | Claude Code | Copilot CLI | Kiro | Aider | OpenCode | Cline | Gemini CLI |
+|---------|-------------|-------------|------|-------|----------|-------|------------|
+| **Session Summarization** | ✅ Automatic | ❌ | ✅ Auto at 80% | ✅ Commits | ✅ Prompts | ❌ | ❌ |
+| **Codebase Analysis** | ✅ LSP+MCP | ✅ Explore Agent | ✅ LSP | ✅ Repo Map | ✅ LSP | ⚠️ Basic | ✅ ReAct Loop |
+| **Context Management** | ✅ Advanced | ✅ Auto-compact | ✅ Meter | ✅ Repo-wide | ✅ SQLite | ⚠️ Basic | ⚠️ Basic |
+| **Parallel Agents** | ✅ Sub-agents | ✅ 4 Agents | ❌ | ❌ | ❌ | ✅ Multiple | ❌ |
+| **Programmatic API** | ✅ SDK | ✅ SDK (Preview) | ❌ | ❌ | ⚠️ Non-interactive | ✅ gRPC | ❌ |
+| **Background/Daemon** | ⚠️ Subprocess | ❌ | ❌ | ❌ | ❌ | ✅ Full | ❌ |
+| **Multi-Model Support** | ✅ 3 Models | ❌ Gemini only | ❌ | ✅ Many | ✅ 70+ | ❌ | ❌ Gemini only |
+| **Git Integration** | ✅ Strong | ✅ GitHub-native | ⚠️ Basic | ✅ Git-first | ⚠️ Basic | ⚠️ Basic | ⚠️ Basic |
+| **MCP Support** | ✅ Native | ✅ Yes | ❌ | ❌ | ✅ Yes | ✅ Yes | ✅ Yes |
+
+---
+
+## Pricing Comparison
+
+| Tool | Model | Monthly Cost | Usage Type | API Available |
+|------|-------|--------------|------------|---------------|
+| **Claude Code** | Subscription | $20 (Pro) / $100-200 (Max) | Average $6/day | ✅ Yes |
+| **Claude Code** | API | Pay-per-token | $3-6 per 1M input tokens | ✅ Primary |
+| **Copilot CLI** | Subscription | $10 (Pro) / $39 (Pro+) | Premium requests | ⚠️ SDK Preview |
+| **Kiro** | Unknown | Unknown | Unknown | ❌ Not documented |
+| **Aider** | Bring Your Own | $0 (tool) + API costs | Per API call | ✅ Use any API |
+| **OpenCode** | Bring Your Own | $0 (tool) + API costs | Per API call | ✅ 70+ providers |
+| **Cline** | Unknown | Unknown | Unknown | ❌ Not documented |
+| **Gemini CLI** | Google Cloud | Variable | Via Code Assist | ✅ Google Cloud |
+
+### Cost Optimization Strategies
+
+**1. API vs Subscription:**
+- Pro subscription = ~$150 API usage equivalent
+- Heavy users save money with direct API
+- Light users benefit from subscription predictability
+
+**2. Batch Processing:**
+- Claude Batch API: 50% savings
+- Good for bulk summarization tasks
+
+**3. Token Caching:**
+- Claude: 90% discount on cached tokens
+- Critical for agentic workflows with large system prompts
+- Repeatedly sending codebase context benefits massively
+
+**4. Bring Your Own Key (BYOK) Tools:**
+- Aider and OpenCode let you use any API
+- Compare pricing across providers
+- OpenRouter for aggregated access
+
+---
+
+## Technical Integration Guide
+
+### 1. Claude Code SDK Integration
+
+**Python Setup:**
+```bash
+pip install claude-agent-sdk
+```
+
+**Basic Usage:**
+```python
+import anyio
+from claude_agent_sdk import query
+
+async def summarize_code(file_path: str):
+    prompt = f"Summarize the code in {file_path}"
+    async for message in query(prompt=prompt):
+        print(message)
+
+anyio.run(summarize_code("./src/main.py"))
+```
+
+**TypeScript Setup:**
+```bash
+npm install @anthropic-ai/claude-agent-sdk
+```
+
+**Configuration Options:**
+```python
+# Use project settings
+await query(
+    prompt="Analyze codebase",
+    setting_sources=["project"]
+)
+```
+
+### 2. GitHub Copilot SDK Integration
+
+**Node.js/TypeScript:**
+```bash
+npm install @github/copilot-cli-sdk
+```
+
+**Python:**
+```bash
+pip install copilot
+```
+
+**Basic Pattern:**
+- Multi-turn conversations
+- Custom tool execution
+- Session lifecycle management
+- Same engine as Copilot CLI
+
+### 3. Cline Daemon Integration
+
+**Start Background Instance:**
+```bash
+# Launch new instance
+cline instance new --default
+
+# Get instance list
+cline instance list
+```
+
+**gRPC Integration:**
+```python
+# Connect to Core Service (port 50051)
+# Connect to Host Bridge (port 50052)
+# Use gRPC client to send commands
+```
+
+**Architecture:**
+- Core Service handles task operations
+- Host Bridge handles platform-specific ops
+- Independent instances on consecutive ports
+
+### 4. OpenCode Non-Interactive Mode
+
+**Automation Script:**
+```bash
+#!/bin/bash
+# Summarize all Python files
+for file in src/**/*.py; do
+    opencode "Summarize $file" >> summaries.txt
+done
+```
+
+**CI/CD Integration:**
+```yaml
+- name: Code Summary
+  run: opencode "Summarize changes in this PR"
+```
+
+### 5. MCP Server Integration
+
+**Standard Pattern:**
+```python
+# MCP server runs as local process
+# Communicate via stdin/stdout
+# No data sharing between processes
+
+import subprocess
+
+mcp_server = subprocess.Popen(
+    ['mcp-server', '--tool', 'code-analysis'],
+    stdin=subprocess.PIPE,
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE
+)
+
+# Send request
+request = json.dumps({"action": "summarize", "file": "main.py"})
+mcp_server.stdin.write(request.encode())
+mcp_server.stdin.flush()
+
+# Read response
+response = mcp_server.stdout.readline()
+result = json.loads(response)
+```
+
+### 6. Subprocess Management Pattern
+
+**Python Example:**
+```python
+import subprocess
+import json
+
+def run_agent_cli(command: str):
+    """Generic agent CLI subprocess pattern"""
+    process = subprocess.Popen(
+        ['agent-cli'],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+
+    # Send command
+    message = json.dumps({"command": command})
+    stdout, stderr = process.communicate(input=message)
+
+    return json.loads(stdout)
+
+# Usage
+result = run_agent_cli("summarize codebase")
+```
+
+### 7. Best Practices for Programmatic Integration
+
+**Error Handling:**
+```python
+async def safe_query(prompt: str, retries: int = 3):
+    for attempt in range(retries):
+        try:
+            async for message in query(prompt=prompt):
+                yield message
+            break
+        except Exception as e:
+            if attempt == retries - 1:
+                raise
+            await asyncio.sleep(2 ** attempt)
+```
+
+**Context Window Management:**
+```python
+def check_context_usage(messages: list) -> float:
+    """Monitor context window usage"""
+    # Estimate tokens (rough: 4 chars = 1 token)
+    total_chars = sum(len(m) for m in messages)
+    estimated_tokens = total_chars / 4
+
+    # Claude Sonnet 4.5 has 200K context
+    usage_percent = (estimated_tokens / 200_000) * 100
+
+    if usage_percent > 80:
+        # Trigger summarization
+        return summarize_conversation(messages)
+
+    return usage_percent
+```
+
+**Batch Processing:**
+```python
+async def batch_summarize(files: list[str]):
+    """Process multiple files efficiently"""
+    summaries = []
+
+    for file in files:
+        prompt = f"Summarize {file} in 2-3 sentences"
+        summary = await query(prompt=prompt)
+        summaries.append({
+            "file": file,
+            "summary": summary
+        })
+
+    return summaries
+```
+
+---
+
+## Use Case Recommendations
+
+### When to Use Each Tool
+
+**Claude Code:**
+- ✅ Need autonomous coding with deep codebase understanding
+- ✅ Complex multi-file refactoring
+- ✅ Long-running development sessions
+- ✅ Want session summaries automatically
+- ✅ Need programmatic API integration
+- ❌ Budget-constrained (expensive for heavy use)
+
+**GitHub Copilot CLI:**
+- ✅ Already using GitHub ecosystem
+- ✅ Need parallel specialized agents (Explore, Review, Plan, Code)
+- ✅ Want fast codebase analysis without context pollution
+- ✅ Enterprise with GitHub Business/Enterprise
+- ✅ Prefer subscription predictability
+- ❌ Need multi-provider model support
+
+**Kiro:**
+- ✅ Want automatic summarization at 80% context threshold
+- ✅ Need visual context usage meter
+- ✅ Highest accuracy benchmarks (77%)
+- ✅ Complex component logic and interactive elements
+- ❌ Limited public documentation on pricing/API
+
+**Aider:**
+- ✅ Git-first workflow is critical
+- ✅ Need repository-wide understanding
+- ✅ Multi-file coordinated changes
+- ✅ Want automatic commit message generation
+- ✅ Prefer BYOK (bring your own key)
+- ❌ Complex functional requirements (benchmark weakness)
+
+**OpenCode:**
+- ✅ Privacy is top priority
+- ✅ Want freedom from vendor lock-in
+- ✅ Need to use multiple AI providers (70+)
+- ✅ Prefer local session storage
+- ✅ Want Plan agent for analysis without changes
+- ❌ Need advanced autonomous features
+
+**Cline:**
+- ✅ Need true daemon/background mode
+- ✅ Multiple parallel agent instances
+- ✅ Want gRPC API integration
+- ✅ Building larger system with agent orchestration
+- ✅ Long-running background tasks
+- ❌ Simple single-session workflows
+
+**Gemini CLI:**
+- ✅ Already using Google Cloud
+- ✅ Need security analysis and vulnerability scanning
+- ✅ Want ReAct loop architecture
+- ✅ Google Search grounding important
+- ❌ Need daemon mode or advanced programmatic access
+
+---
+
+## Future Trends (2026 and Beyond)
+
+### 1. MCP Standardization
+- 2026 is the year of enterprise MCP adoption
+- All major tools converging on MCP for integrations
+- Open governance through AAIF and Linux Foundation
+- Security improvements addressing 2025 vulnerabilities
+
+### 2. Parallel Agent Architectures
+- Moving from sequential to parallel execution
+- Specialized agents for specific tasks (Explore, Review, Plan)
+- 3x+ speed improvements from parallelization
+- Better resource utilization
+
+### 3. Advanced Context Management
+- Automatic summarization at threshold (80-95%)
+- Persistent codebase memory across sessions
+- Smart token caching (90% discount)
+- Subagent context extension strategies
+
+### 4. Programmatic APIs Maturing
+- SDKs becoming standard (Python, TypeScript, Go, .NET)
+- From experimental to production-ready
+- Multi-turn conversation support
+- Full lifecycle control
+
+### 5. Daemon/Background Modes
+- Persistent agent processes
+- Proactive monitoring and intervention
+- Unix socket and gRPC communication
+- Multiple parallel instance management
+
+### 6. Cost Optimization
+- Batch APIs for 50% savings
+- Aggressive token caching strategies
+- BYOK tools for provider flexibility
+- API vs subscription calculators
+
+### 7. Security & Trust
+- Addressing MCP security vulnerabilities
+- Better tool permission models
+- Audit logging and compliance
+- Enterprise-grade security controls
+
+---
+
+## Conclusion
+
+The landscape of agent CLI tools in 2026 offers robust options for code summarization and analysis:
+
+**Best Overall:** Claude Code for comprehensive autonomous coding with session summarization
+
+**Best Parallelization:** GitHub Copilot CLI with 4 specialized agents running concurrently
+
+**Best Auto-Summarization:** Kiro with 80% threshold automatic context management
+
+**Best Git Integration:** Aider with repository mapping and commit summarization
+
+**Best Privacy:** OpenCode with 70+ model support and local storage
+
+**Best Background Mode:** Cline with true daemon capabilities via gRPC
+
+**Best for Google Cloud:** Gemini CLI with security analysis integration
+
+All tools support programmatic integration to varying degrees, with Claude Code SDK and GitHub Copilot SDK leading in maturity. MCP (Model Context Protocol) is becoming the standard for tool integration across the ecosystem.
+
+Choose based on your specific needs: autonomous capability, parallelization, privacy, cost, or integration requirements.