Technical Summary: Agentic Coding Needs Proactivity, Not Just Autonomy

1. Problem Statement

The landscape of software development is shifting from inline code completion to autonomous coding agents capable of editing repositories, managing pull requests, and executing scheduled routines. While current systems demonstrate significant autonomy (the ability to act without supervision), they lack a clear definition and evaluation framework for proactivity.

The core problem is the absence of a mechanism for agents to decide when to act, what to show, and when to remain silent. Current agents often operate on explicit prompts or fixed schedules (Level 2), failing to distinguish between "being active" and "being useful." There is no clear account of:

• What proactivity means in the context of software development.
• How it differs from simple autonomy.
• What acceptance criteria proactive, long-horizon tasks should satisfy.
• Which metrics determine if unsolicited agent behavior is beneficial rather than merely intrusive.

Without these definitions, the field cannot evaluate whether an agent's "insight policy"—the decision-making process regarding what matters next—is effective.

2. Methodology and Framework

The authors propose a theoretical framework grounded in mixed-initiative interaction (Horvitz, 1999) and autonomy taxonomies (Händler, 2023). The methodology consists of three main components:

A. Decision-Theoretic Formulation

The paper models proactive behavior using a decision-theoretic equation where an agent selects an action $a^*$ to maximize expected utility while minimizing interruption cost:
$$a^* = \arg\max_{a \in A} \mathbb{E}_{p(o|a,s_t,E_t)} [U(o; \theta)] - \text{Cost}_{int}(s_t, a; \theta)$$

• Action Space ($A$): Includes notify, question, draft, and crucially, stay silent.
• State ($s_t$): Developer state (open buffers, calendar, sprint deadlines).
• Event Stream ($E_t$): Continuous stream of code, project, and communication events.
• Cost of Interruption ($\text{Cost}_{int}$): A variable cost based on developer focus, workflow phase, and recovery time.
• Insight: Defined as a context-grounded, time-sensitive hypothesis paired with a decision to act or stay silent.

B. Three-Level Taxonomy of Proactivity

The authors categorize agentic coding systems into three levels based on their ability to compute the terms in the decision equation:

1. Level 1 (Reactive): Agents run only when explicitly prompted. They have no persistent environmental presence or time model between requests.
2. Level 2 (Scheduled): Agents run on schedules or predefined triggers (e.g., webhooks, GitHub events). They may filter or rank outputs but do not learn a cross-context, per-developer interruption policy. Silence is not a learned choice; it is merely the absence of a trigger.
3. Level 3 (Situation-Aware): Agents continuously monitor event streams, compute utility and interruption costs across the full action space (including stay silent), and update their policy ($\theta$) based on developer feedback. They decide what to show, when, and whether showing anything is the correct action.

C. Evaluation Protocol

The paper proposes adapting Active User Simulation (Nathani et al., 2026) to software development. Instead of scoring final task completion (as in SWE-Bench), the evaluation focuses on the insight stream.

• Trace Collection: Timestamped, replayable developer-workflow traces aligning repository diffs, CI logs, communication, and IDE state.
• Scenario Structure: Long-horizon scenarios include weak signals, distractors, confirming evidence, and moments where silence is the correct action.
• Metrics:
  1. Insight Decision Quality (IDQ): Scores whether the agent chose the right action (notify, question, draft, silence) at the right time.
  2. Context Grounding Score (CGS): Measures if shown insights are supported by recoverable evidence (files, diffs, logs) and if the message is faithful to that evidence.
  3. Learning Lift (LL): Measures the improvement in IDQ when a policy adapts to developer feedback compared to a frozen policy.

3. Key Contributions

The paper makes four specific contributions:

1. A Three-Level Taxonomy: A formal separation of autonomy from proactivity, distinguishing between reactive, scheduled, and situation-aware agents.
2. Comparative Audit: An analysis of five contemporary coding agents (Cursor, GitHub Copilot, Jules, Claude Code, and a LangChain reference architecture) against five practical criteria (O1–O5).
   • Finding: Current deployed agents cluster around Level 2. None publicly document meaningful interruption cost computation (O1), explicit silence as a learned action (O2), or policy updates based on per-developer feedback (O3).
3. Prototype Level 3 Engine: A conceptual architecture centered on the "insight" unit, maintaining a developer mental model and learning from response.
4. Evaluation Metrics: The proposal of IDQ, CGS, and LL as the primary units for measuring proactive behavior, shifting focus from task completion to the quality of the insight policy.

4. Results and Findings

The paper presents no measured experimental results from a deployed Level 3 system; it is a position and measurement proposal. However, the audit of existing systems yields the following findings:

• The "Proactivity Gap": While systems like Cursor Automations and Claude Code Routines support scheduled tasks (Level 2), they lack evidence of computing interruption costs or treating silence as an explicit, learned action.
• O1-O5 Audit:
  • O1 (Interruption Cost): No deployed agent documents computing this.
  • O2 (Explicit Silence): No agent documents silence as a learned action in the action space.
  • O3 (Feedback Updates): Evidence is weak; some systems expose memory, but the effect on surfacing decisions is unclear.
  • O4 (Cross-Context): Partial evidence exists for ingesting multiple context categories.
  • O5 (Initiation Channel): Widely satisfied; agents can show messages without separate tools.
• Conclusion on Current State: The frontier is not in inventing new capabilities but in adapting existing interaction patterns to software development specifics, particularly the judgment of when to interrupt and when to remain silent.

5. Significance and Claims

The paper claims that the next generation of coding agents must be evaluated not by how much work they complete, but by the quality and improvement of their insight policy.

• Shift in Paradigm: Proactivity should be viewed as "mixed-initiative collaboration" rather than just automation. An agent is proactive if it learns which contributions deserve attention, which evidence makes them credible, and how to adapt after feedback.
• Accountability: The framework makes proactivity testable. By defining "insights" and measuring IDQ, CGS, and LL, the field can move beyond product labels to measurable behaviors.
• Design Implications: A true Level 3 agent requires an interface that makes deferred insights inspectable, allowing developers to accept, edit, or dismiss suggestions, thereby providing the feedback loop necessary for learning.
• Modesty: The authors acknowledge that this is a proposal. Simulated developers may diverge from real users, and interruption findings from real-time work may not transfer cleanly to asynchronous messages. The paper advocates for reporting uncertainty and treating proactivity as a property involving real developers rather than a single benchmark score.

In summary, the paper argues that for agentic coding to mature, it must evolve from "doing more" to "deciding better," with a specific focus on the strategic value of silence and the continuous adaptation of interruption policies.