Terminal-Native AI Coding Agent with Multi-Model Architecture and Adaptive Context Management

opendev · Tech · 2026 · source Agentic: yes · promotional bias: low · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Terminal-native autonomous coding agents

OpenDev needed a production-ready command-line coding agent that could survive long sessions, execute powerful tools safely, and add capabilities without exhausting the model context window.

Constraints:

• Finite context windows limit long coding sessions.
• Agents with shell access can perform destructive operations.
• Tool catalogs can overwhelm prompt budgets.
• Different workflows benefit from different model capabilities.
• The agent operates in terminal environments where developers manage source control, builds, and deployments.

Architecture

OpenDev uses a compound AI architecture: per-workflow LLM binding, a planner/executor separation, adaptive context compaction, lazy MCP tool discovery, subagents with allowed-tool restrictions, Reflexion-style critique, and a defense-in-depth safety architecture for terminal operations.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  terminal_user_interface["Terminal user interface"] --> main_agent["Main agent"]
  main_agent --> planner_model["Planner model"]
  main_agent --> executor_model["Executor model"]
  main_agent --> subagentmanager["SubAgentManager"]
  subagentmanager --> restricted_subagents["Restricted subagents"]
  main_agent --> mcp_tool_discovery["MCP tool discovery"]
  main_agent --> context_compaction["Context compaction"]
  main_agent --> safety_layers["Safety layers"]
  executor_model --> safety_layers

Components

Data flow

A user request enters the terminal agent. Planning and execution roles route work to configured models and tools, MCP tool schemas are discovered lazily, observations are compacted as sessions grow, subagents execute restricted workflows in parallel when needed, and safety layers mediate destructive actions.

Why this architecture

OpenDev treats a coding agent as a compound AI system because no single model call can manage long context, tool expansion, safety, planning, execution, and critique reliably in a terminal environment.

Models used: Planner model · Executor model · Critique model · Vision model · Compact model

Scale

• Adaptive context management reduced peak context consumption by about 54%.
  “Results demonstrate approximately 54% reduction in peak context consumption”summary, stated
• Session length extended from 15-20 turns to 30-40 turns without emergency compaction.
  “session lengths extending from 15-20 turns to 30-40 turns without emergency compaction”summary, stated
• A 100-tool MCP catalog averaging 200 tokens per schema would consume 20,000 tokens if eagerly loaded.
  “a system with 100 external tools, each schema averaging 200 tokens, consumes 20,000 tokens purely for tool definitions before the first user message.”summary, stated

Alternatives considered (roads not taken)

Eagerly load all MCP tool schemas

Rejected because: Large tool catalogs would consume too much context before work begins.

Use one monolithic model for every workflow

Rejected because: Different roles benefit from planner, critique, vision, compact, and executor model specialization.

Use prompt engineering alone

Rejected because: The paper argues context, safety, and capability-extension problems cannot be solved by prompting alone.

Patterns

tool-use-orchestration (agent tooling)

OpenDev controls terminal and MCP tool use through workflow routing, tool discovery, and safety layers.

multi-agent-orchestration (agent coordination)

The main agent can spawn restricted subagents and execute multiple subagent calls concurrently.

context-engineering (context management)

Adaptive compaction, lazy tool schemas, and bounded-growth rules manage context over long sessions.

safety-policy-enforcement (agent safety)

The terminal agent uses defense-in-depth controls for destructive operations.

Tradeoffs

Use multiple workflow-bound models.

Chose Planner, executor, critique, vision, and compact models over A single model for all work.

Rationale: Specialized models optimize reasoning, execution, critique, vision, and summarization needs independently.

Lazily discover tools.

Chose Search and discover MCP tools as needed over Eagerly loading all tool schemas.

Rationale: Lazy discovery preserves context budget while retaining extensibility.

Restrict subagent tools by workflow.

Chose Allowed-tool scoped subagents over Full tool access for every spawned agent.

Rationale: Tool restriction limits risk and keeps each subagent's schema smaller.

Gotchas (what bit them)

Large tool catalogs can consume the context window before the task starts.

Root cause: Every tool schema costs tokens if loaded eagerly.

Resolution: Use lazy MCP tool discovery and include schemas only after discovery.

Long sessions decay without context compaction.

Root cause: Terminal coding sessions routinely exceed finite model token budgets.

Resolution: Progressively reduce older observations with adaptive context compaction and compact models.

Terminal agents can damage workspaces if safety is only prompt-level.

Root cause: Agents can execute arbitrary shell commands in developer environments.

Resolution: Use defense-in-depth safety controls and restricted subagent tool schemas.

Evaluation

The paper reports architectural outcomes such as context reduction and longer sessions, and situates the design against coding-agent evaluation ecosystems rather than a single benchmark leaderboard.

Metrics: 54% peak context reduction. · 15-20 turns extended to 30-40 turns. · Tool schema token budget examples. · Safety architecture coverage.

Outcomes

• Peak context consumption dropped about 54%.
• Sessions extended from 15-20 turns to 30-40 turns without emergency compaction.
• The architecture supports lazy MCP tools, subagents, safety controls, and multi-model routing.

The paper reports context-window and turn-count improvements, plus a 100-tool/20,000-token schema example for lazy discovery.