acceptodds
Under review as a conference paper at ICLR 2027

StateHarness: Maintaining Evolving Project State for Long-Horizon Coding Agents

Abstract

Long-horizon coding requires agents to maintain an evolving view of the project they are changing: what problem is currently being solved, what has already been learned or modified, which other artifacts may be affected, and what work re- mains unresolved. When this information is scattered across a growing interaction history, local edits can become disconnected from their later consequences and progress can be difficult to carry forward. We introduce StateHarness, a runtime framework that maintains evolving project state without updating model param- eters. The working agent records its current problem and hypothesis, important findings and decisions, discovered repository relationships, and unfinished work. Runtime support prompts record updates, searches for callers, tests, and documen- tation that may be affected by a change, and maintains a compact working brief for subsequent decisions. When behavioral signals accumulate, a separate diagnostic session revisits the recorded history and surfaces overlooked evidence. Across three repository-level evaluations, StateHarness improves task completion and several measures of change consistency. On RefactorBench, full-chain completion increases from 29.4% to 35.3% and cleanup-check accuracy from 87.0% to 95.4%. On five LHTB software-engineering tasks, mean reward improves from 0.427 to 0.576, exceeding LongHorizon-Harness at substantially lower recorded execution cost. On ChainSWE, bug-fix rate increases from 35.1% to 39.5% and residual debt decreases from 60 to 43 items, although pass-to-pass regressions increase. These results show that maintaining project state can improve long-horizon coding while introducing measurable execution and regression trade-offs. Code is available at https://anonymous.4open.science/r/StateHarness.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
agent harness, runtime governance, training-free methods, long-horizon coding agents

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_xek4OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

StateHarness introduces a training-free runtime framework for maintaining evolving project state in long-horizon coding tasks. It combines persistent project records, a compact working brief, change-impact retrieval, and occasional diagnostic sessions, and evaluates the framework across three repository-level benchmarks. Across multiple long-horizon coding benchmarks, StateHarness improves the task metrics over Claude Code Sonnet 5.

Critical strengths

S1. The work is well motivated. Long coding projects require agents to track changing requirements, prior findings, dependencies, and unfinished work. Maintaining an explicit project state addresses a practical challenge in these tasks.

S2. The method is simple and easy to follow. The paper clearly describes how project records, brief updates, change-impact retrieval, and diagnostic feedback support the working agent during execution.

Critical weaknesses

W1. The evaluation uses only Claude Sonnet 5. Testing additional model families and capability levels (such as GPT-6-astra, claude Opus 5 or 5.5, claude Fable 5 or 5.1) would help distinguish which behaviors stronger agents already exhibit and which limitations still require explicit runtime support.

W2. The gains are not sufficiently attributed to individual components. The evaluation does not isolate the effects of structured project state, reminders and testing guidance, change-impact retrieval, and additional diagnostic sessions. Incomplete accounting of diagnostic tokens further limits assessment of the contribution and cost of extra inference.

W3. It is unclear why this mechanism (to be specific, the four forms of records and runtime support) is necessary, compared to other baselines such as a well-designed memory system. This diminishes the contribution of this work, limiting our understanding of what is actually useful in long-horizon agents.

Questions for authors

Q1. Why are diagnostic-session tokens not fully included in the reported costs? Please report total token usage including these sessions, together with the diagnostic model and the frequency of diagnostic calls. (W2)

Q2. How much of the improvement comes from structured project state, reminders and additional testing, change-impact retrieval, or separate diagnostic sessions? I suggest component ablations and controls with comparable inference and testing budgets. (W2)

Q3. Do the gains persist across model families and capability levels? Which failure modes are already handled by stronger baseline agents, and which still benefit from StateHarness? (W1)

Q4. Could you provide more justification for the mechanism? You could justify the design with a case study or compare this method with more baselines, such as a well-designed memory system for long-horizon coding agents. (W3)

1 comment

We thank the reviewer for the constructive feedback. We have added component ablations and repeated runs, and provide additional cost accounting and clarification of the proposed mechanism below.

W2 + Q2 — Component contributions and ablations

We conducted a component ablation on all 37 ChainSWE chains, progressively adding StateHarness's runtime mechanisms. V1 is a prompt-only baseline that provides the same record-keeping instructions and templates without runtime support.

VariantBug Fix (%) ↑P2P ↓Residual Debt ↓
V0 Claude Code35.11660
V1 Prompted records38.63157
V2 + Brief sync/reminders39.52750
V3 + Change-impact retrieval38.62045
V4 Full StateHarness39.52343

Prompted records improve the bug-fix rate from 35.1% to 38.6%, while full StateHarness further improves it to 39.5%. More importantly, runtime support reduces residual debt from 57 to 43 and P2P regressions from 31 to 23 relative to prompted records alone.

Adding diagnosis (V3 → V4) improves bug fixing (38.6% → 39.5%) and reduces residual debt (45 → 43), while P2P regressions increase from 20 to 23. These ablations show the incremental contribution of each component, although inference and testing budgets are not strictly matched.

W2 + Q1 — Diagnostic-session cost accounting

The original submission did not separately report diagnostic-session token usage. We now provide the complete ChainSWE token breakdown, including auxiliary sessions.

MethodMain Tokens (K)Auxiliary Tokens (K)Combined Tokens (K)Auxiliary Calls / Chain
Claude Code24.9024.90
StateHarness35.32.237.50.11
LongHorizon-Harness82.3125.7208.019.5

StateHarness's diagnostic sub-agent (drift-analyst) uses Claude Code's sonnet model alias, without explicitly pinning a specific model version. It was invoked 4 times across 37 chains (0.11 calls per chain).

Including diagnostic sessions, StateHarness uses 37.5K tokens per chain, compared with 24.9K for Claude Code and 208.0K for LongHorizon-Harness. This shows that StateHarness introduces additional inference cost over the base agent while remaining substantially more token-efficient than LongHorizon-Harness.

We will include this complete breakdown in Appendix B.5.

W1 + Q3 — Generalization across working models

Our benchmark experiments use Claude Sonnet 5 as the working model to isolate the effects of runtime organization.

We added two independent runs on all 37 ChainSWE chains. Across the three runs, StateHarness achieves a mean bug-fix rate of 39.8%, compared with 34.8% for Claude Code, while mean residual debt decreases from 61.3 to 43.7.

These results demonstrate consistent improvements across repeated runs with Claude Sonnet 5. Generalization to stronger models and other model families remains to be evaluated.

W3 + Q4 — Why runtime state maintenance beyond memory?

We agree that structured memory and progress tracking are useful and established practices. Our prompt-only baseline confirms their value, improving bug fixing from 35.1% to 38.6%.

StateHarness addresses a more specific problem: an agent's own code changes can make its previously recorded task understanding outdated. The framework therefore goes beyond preserving information. It maintains a current working brief, retrieves potentially affected files after changes, and uses runtime feedback to revisit overlooked evidence.

Our sqlglot case study (§4.6, Figure 4) illustrates this mechanism. Both agents initially make broad parser changes, but StateHarness performs additional regression checking, detects a previously passing Databricks test that now fails, and narrows its patch. The final patch passes the target test without introducing regressions.

Together, the ablation results and sqlglot case study demonstrate the contribution of runtime state maintenance beyond prompted record-keeping. We will make this methodological distinction clearer in §2.

Reviewer_2GcmOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

StateHarness is a runtime framework that helps coding agents maintain project state during long tasks. It combines persistent records of findings and unfinished work, a compact working brief, change-impact retrieval, and occasional diagnostic sessions. Experiments on RefactorBench, LHTB, and ChainSWE show improvements in task completion, although these come with additional execution cost and, on ChainSWE, more regressions.

Critical strengths
  • The agent records why related files need attention and whether that work has been completed, while the working brief and diagnostic sessions help bring relevant evidence back into use. This is a reasonable design for tasks where completing a local edit can leave consequences elsewhere in the repository.
  • The evaluation covers three complementary settings, uses the same working model within comparisons, and measures outcomes through tests or external verifiers. The improvement in RefactorBench cleanup checks is very relevant to the proposed mechanism. Reporting both improvements and increased regressions also gives a useful picture of the trade-offs.
Critical weaknesses
  • The lack of component ablations. StateHarness introduces structured records, retrieval, reminders, testing guidance, and diagnostic sessions together. The current comparisons establish the usefulness of the overall package, but do not establish how much the explicit state representation contributes beyond stronger instructions or additional verification.
  • The experiments are not comprehensive. RefactorBench contains 17 combined tasks, LHTB includes only five tasks, and all experiments use one working model. The evaluation is relevant to the paper’s motivation, but its coverage is limited. It uses small task sets and adapted task constructions, including chained RefactorBench tasks and a single-request version of ChainSWE. This makes it difficult to tell whether the gains extend to broader coding workloads. Results on a larger, representative coding benchmark under its standard protocol would provide a useful complement to these focused evaluations.
  • The idea is not very novel. Persistent notes, progress tracking, compact summaries, and reflective feedback are established practices. For example, Anthropic’s work on long-running agents [1] already combines progress files, structured feature tracking, and verification to maintain continuity. StateHarness adds runtime support around these ideas, but the paper does not clearly analyze which design constitutes a big methodological innovation. Its relationship to online adaptive approaches such as Continual Harness [2], which refines prompts, skills, and memory during execution, also deserves discussion.

[1] Justin Young. Effective harnesses for long-running agents. Anthropic Engineering, 2025.

[2] Seth Karten et al. Continual Harness: Online Adaptation for Self-Improving Foundation Agents. arXiv:2605.09998, 2026.

Questions for authors
  1. How does StateHarness compare with a baseline where the model is prompted to just write down skill.md/todo.md etc? What is the main methodological contribution beyond existing structured note-taking and progress-file workflows?
  2. How stable are the results across repeated runs and other working models, and does the approach help when tasks arrive across separate sessions?
  3. Can the authors try this on some more common coding benchmarks such as DeepSWE, ProgramBench?
1 comment

We thank the reviewer for the constructive feedback. We address the component contributions, evaluation scope, and methodological novelty below.

W1 + Q1 — Component ablations and comparison with prompted notes

We added a component ablation on all 37 ChainSWE chains, including a prompt-only baseline that provides the same record-keeping instructions and templates without StateHarness's runtime mechanisms.

VariantBug Fix (%) ↑P2P ↓Residual Debt ↓
V0 Claude Code35.11660
V1 Prompted records38.63157
V2 + Brief sync/reminders39.52750
V3 + Change-impact retrieval38.62045
V4 Full StateHarness39.52343

The prompt-only baseline already captures most of the bug-fix improvement (35.1% → 38.6%, versus 39.5% for StateHarness). This shows that structured note-taking itself is useful.

The additional contribution of runtime support is stronger change consistency: compared with prompted records alone, StateHarness reduces residual debt from 57 to 43 and P2P regressions from 31 to 23. The gains are not monotonic across all metrics, suggesting that the mechanisms primarily help maintain consistency rather than uniformly improve bug fixing.

W2 + Q2 + Q3 — Robustness and evaluation scope

Repeated runs. We added two independent runs alongside the submission's original run, using the same 37 ChainSWE chains for each method.

MethodMean Bug Fix (%) ↑Mean P2P ↓Mean Residual Debt ↓
Claude Code34.820.361.3
LongHorizon-Harness32.744.369.7
StateHarness39.823.043.7

StateHarness achieves higher bug-fix rates and lower residual debt than Claude Code in all three runs, although P2P regressions remain a trade-off.

Benchmark coverage. We selected three complementary benchmarks to evaluate two key challenges in long-horizon coding: sustained execution and change consistency.

LHTB evaluates sustained execution over complex, multi-step tasks, while RefactorBench and ChainSWE evaluate whether agents can maintain consistency across successive code changes, where later edits may affect earlier work and dependent artifacts.

These settings directly reflect the two challenges StateHarness is designed to address. While broader evaluations on standard coding benchmarks would be valuable, our current experiments focus on these two challenges directly targeted by StateHarness.

W3 — Methodological novelty beyond existing harnesses

We agree that persistent notes, progress files, and testing guidance are established practices. Anthropic's long-running agent harness uses structured feature lists and progress files to preserve continuity across sessions. Continual Harness adapts the agent's prompts, skills, sub-agents, and memory during execution.

StateHarness targets a different failure mode: the agent's own code changes can invalidate its self-authored task records, including hypotheses, discovered dependencies, and unresolved consequences.

Rather than evolving the harness itself, StateHarness uses runtime brief synchronization, change-impact retrieval, reminders, and triggered diagnostic sessions to maintain evolving task state.

Our sqlglot case study (§4.6, Figure 4) illustrates the motivation: both agents initially make broad parser changes, but StateHarness performs additional regression checking, detects a failure in a previously passing Databricks test, and narrows the patch.

Reviewer_1Z6mOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes StateHarness, a training-free runtime layer around a coding agent (Claude Code with Sonnet 5) that maintains an explicit project state across long-horizon coding tasks. It combines four mechanisms: persistent project records (task state, event log, relation notes, procedure guidance), a working brief refreshed by fixed rules, change-impact retrieval that flags affected callers/tests/docs when files change, and a threshold-triggered diagnostic session that reviews the records in a fresh context. On three repo-level benchmarks (RefactorBench, LHTB, ChainSWE), it improves over unmodified Claude Code, e.g., full-chain completion 29.4 to 35.3 on RefactorBench, mean reward 0.427 to 0.576 on LHTB (vs 0.525 for LongHorizon-Harness), and bug-fix rate 35.1 to 39.5 on ChainSWE, but pass-to-pass regressions worsen from 16 to 23. Recorded cost stays well below LongHorizon-Harness (35.3K vs 208.0K tokens on ChainSWE).

Critical strengths
  1. Well-motivated problem. This paper identifies and addresses the loss of project-level state (hypotheses, ruled-out causes, affected artifacts, unfinished work), which is an important problem for long-horizon agents.
  2. Change consistency evaluations. In addition to task completion/success metrics, this paper evaluates and, in some cases, improves on change consistency (e.g., dependent file cleanup for RefactorBench)
Critical weaknesses
  1. Improvements could be within run-to-run noise. There are no estimates of run-to-run variance. Since ChainSWE has 37 tasks, the +4.4pt bug-fix gap would correspond to 1-2 issues. LHTB drops one of six tasks for exceeding the execution budget, and everything runs one model inside one agent. This makes it questionable if the improvements are statistically significant.
  2. Lack of ablations or hyperparameter tuning: There are no experiments to isolate the impact of each of the four components introduced by the method. Moreover, hyperparameters like the diagnostic threshold, the brief window, and edit reminder cadence aren't tuned to measure their impact on the overall approach.
  3. Limited metric comparability and incomplete cost accounting. Residual debt includes stale recorded state, which only record-keeping systems can incur, making it a method-dependent supplementary metric (App. B.4). More detail on how these problems are counted would help assess the reported improvement. RefactorBench also uses a chained protocol, limiting comparison with published per-task results, though both baselines use the same chains. Finally, diagnostic sessions are "not fully included" in token accounting (App. B.5), so the reported usage does not establish total inference cost. Please report diagnostic-session usage separately or include it in end-to-end cost.
  4. Regressions on ChainSWE. Pass-to-pass regressions worsen from 16 to 23, even though the bug-fix rate improves.
  5. Unclear Novelty. The methodological novelty over Ledger, ProjectGuard, CORVUS, and LongHorizon-Harness is also not clearly established.
Questions for authors
  • Which LHTB task was excluded for exceeding the execution budget, and does including its partial reward change the mean-reward ordering against LongHorizon-Harness?
  • How many independent runs and seeds were used for each reported number? On ChainSWE, is the 35.1 to 39.5 bug-fix gap within run-to-run noise?
  • What drives the pass-to-pass regressions from 16 to 23? Are they concentrated in a few chains, and do they trace to the broader edits that change-impact retrieval encourages?
  • What does a reminders-only variant (working brief plus reminder cadence, no change-impact retrieval or diagnostic session) achieve?
3 comments

We thank the reviewer for the careful reading and the concrete, actionable questions. We address each weakness (W) and question (Q) below.


Q1 — Which LHTB task was excluded, and does it change the ordering?

The excluded task is riscv-core-debug, which has a substantially higher computational cost than the other tasks. The official benchmark configuration allows up to 6 hours for agent execution and 90 minutes for verification.

LHTB:riscv-core-debug. We additionally evaluated StateHarness and LongHorizon-Harness on this task:

MetricLongHorizon-HarnessStateHarness
Primary checks passed (weight 60%)7/1111/11
Additional checks (weight 28%)All passedAll passed
Journal score (weight 12%)0.6670.000
Task reward ↑0.7420.880
Tokens ↓468K197K
6-task mean reward ↑0.5610.627

StateHarness passes all 11 primary checks, compared with 7 for LongHorizon-Harness, while using 58% fewer tokens. Despite a lower journal score, StateHarness achieves a higher overall task reward (0.880 vs. 0.742).

Including this task, StateHarness maintains its lead over LongHorizon-Harness in six-task mean reward (0.627 vs. 0.561).


W1 + Q2 — Run-to-run variance and statistical significance

The reviewer is right that the submission reports single-run results and that, with 37 chains, the original +4.4 percentage-point bug-fix improvement corresponds to a small number of issues. We have therefore added repeated runs to assess run-to-run variability.

Multi-Seed Observations. We evaluated Claude Code, LongHorizon-Harness, and StateHarness on the same 37 ChainSWE chains, using three independent runs per method (the original run plus two additional runs), with otherwise identical configurations. We report per-run results and means across the three runs.

ChainSWE (37 chains)seed 0seed 1seed 2mean
Claude Code — bug-fix %35.136.033.334.8
LongHorizon Harness — bug-fix %32.532.533.332.7
StateHarness — bug-fix %39.539.540.439.8
Claude Code — P2P regressions16202520.3
LongHorizon Harness — P2P regressions47473944.3
StateHarness — P2P regressions23182823
Claude Code — residual debt60655961.3
LongHorizon Harness — residual debt69736769.7
StateHarness — residual debt43404843.7

Across all three runs, StateHarness achieves a higher bug-fix rate and lower residual debt than Claude Code. The average bug-fix improvement is +4.97 percentage points, while residual debt decreases by 17.67. P2P regressions show no clear improvement over Claude Code. These results provide additional evidence that the improvements are consistent across repeated runs.

W2 + Q4 — Component ablations and the reminders-only variant

This is a fair gap: the submission establishes the value of the full package but not the contribution of each mechanism. We have added an ablation that incrementally enables the four mechanisms, on all 37 ChainSWE chains with the submission's configuration:

VariantRecordsBrief sync + remindersChange-impact retrievalDiagnosisWhat its delta isolates
V0 = Claude Code––––baseline
V1 Prompted recordsprompt-only–––instructions alone (the same record-keeping instructions and templates in the initial request, no runtime support)
V2 Records + brief✓✓––runtime maintenance — this is the reviewer's "reminders-only" variant (Q4)
V3 + retrieval✓✓✓–change-impact retrieval
V4 = StateHarness✓✓✓✓diagnostic session

1. Component Ablation Results

ChainSWE (37 chains, seed 0)Bug fix % ↑P2P regr. ↓Residual debt ↓Recorded tokens (K)Tool callsTime (s)
V0 Claude Code35.1166024.975300
V1 Prompted records38.6315728.477340
V2 Records + brief (reminders-only)39.5275030.887351
V3 + retrieval38.6204533.392373
V4 StateHarness39.5234335.396383

Description of the component ablation study

  1. The ablation shows that prompted records account for most of the observed bug-fix gain (35.1% → 38.6%, compared with 39.5% for the full StateHarness). This suggests that Claude Code can already make effective use of structured project records when guided by clear instructions.

  2. Adding runtime mechanisms does not monotonically improve bug-fix rate, but substantially reduces residual debt (57 → 43) and partially mitigates the increase in P2P regressions observed with prompted records alone (31 → 23). Although P2P regressions remain above the original Claude Code baseline (16), these results suggest that the main additional benefit of runtime support lies in maintaining change consistency rather than uniformly improving immediate task success.

2. Hyperparameters Ablation Study. On hyperparameters (diagnostic threshold, brief window, reminder cadence). We agree a sensitivity analysis would strengthen the paper and evaluated diagnostic thresholds of 1, 2, and 4 on a 10-chain subset:

Diagnostic threshold (10-chain subset)Bug fix % ↑P2P regr.↓Diagnostic calls / chain ↓Time (s) ↓
threshold = 133.3160.4560
threshold = 2 (default)43.370.2405
threshold = 440.090368

Interpretation. The results show a trade-off between diagnostic frequency and task performance. A low threshold (1) triggers frequent diagnosis (0.4 calls/chain), increasing execution time while reducing bug-fix performance. A high threshold (4) rarely activates diagnosis (0 calls/chain) and achieves lower execution cost, but slightly lower bug-fix performance and more P2P regressions than the default.

Threshold = 2 provides a better balance, achieving the highest bug-fix rate (43.3%) and fewest P2P regressions (7) with moderate diagnostic overhead (0.2 calls/chain). These results suggest that selective diagnosis is more useful than frequent intervention.

W3 — Metric comparability and cost accounting

Three separate concerns; we address each.

(a) Residual debt includes stale recorded state. Residual debt includes stale recorded state. We agree that including a method-specific category could affect metric comparability. To clarify this, we provide a per-category breakdown of residual debt on ChainSWE,We will add the per-category breakdown to Appendix B.4 (operated on run#1 of the ChainSWE Experiment):

ChainSWE residual debt by categoryClaude CodeStateHarnessLongHorizon-Harness
Stale callers442022
P2P regressions162347
Outdated documentation000
Stale recorded state000
Total604369

Interpretation. The reduction in residual debt (60 → 43) is mainly driven by fewer stale callers (44 → 20), despite a small increase in P2P regressions (16 → 23). This suggests that StateHarness improves cross-file consistency, although it does not eliminate regression risks.

Importantly, stale recorded state contributes zero to all systems. Therefore, the reported improvement does not depend on any method-specific record-keeping metric, ensuring a consistent comparison across methods.

(b) RefactorBench chained protocol vs. published per-task results.

We agree that our chained results are not directly comparable to published per-task scores. However, RefactorBench (Gautam et al., 2025)explicitly supports combining independent refactoring tasks into longer sequences within the same repository.

We use this setting deliberately because our goal is to evaluate whether agents can maintain project consistency across successive code changes. All compared methods use the same chains, task order, and evaluation checks, ensuring a fair comparison within our study.

(c) Diagnostic-session cost accounting.

We extend the ChainSWE cost analysis to include auxiliary-session token usage, covering StateHarness's diagnostic sessions and LongHorizon-Harness's orchestrator and verifier.

ChainSWE, per chain (mean)Non-auxiliary tokens (K)Auxiliary tokens (K)Total tokens (K)Auxiliary calls / chain
Claude Code24.9024.90
StateHarness35.32.237.50.11
LongHorizon-Harness82.3125.7208.019.5

StateHarness's diagnostic tokens are calculated using observed diagnostic calls and per-session token usage. Auxiliary calls refer to diagnostic sessions for StateHarness and auxiliary-role invocations for LongHorizon-Harness.

Interpretation. Including diagnostic sessions brings StateHarness's total token usage to 37.5K per chain, compared with 24.9K for Claude Code and 208.0K for LongHorizon-Harness. Diagnostic sessions contribute 2.2K tokens per chain, reflecting their infrequent activation. StateHarness therefore maintains substantially lower token usage than the multi-role harness while introducing moderate overhead over the base agent. We will incorporate this breakdown into Appendix B.5.

W4 + Q3 — Chain-level analysis of P2P regressions

We examined P2P regressions across all 37 ChainSWE chains to understand where the increase comes from. We count unique failed P2P tests within each chain.

ComparisonSH > CCSH < CCEqual
Number of chains2332

Interpretation. Only two of the 37 chains show higher P2P regression counts under StateHarness. It produces fewer regressions on three chains and the same recorded count on the remaining 32.

W5 — Novelty relative to Ledger, ProjectGuard, CORVUS, LongHorizon-Harness

Ledger tracks tool outcomes, ProjectGuard tracks evolving specifications, CORVUS synchronizes file observations, and LongHorizon-Harness coordinates executor sessions through audited task state.

In contrast, StateHarness addresses a specific failure mode: the agent's own code changes can invalidate its self-authored task records, including hypotheses, discovered dependencies, and unresolved consequences. Our contribution is a runtime mechanism that prompts the agent to track and address change consequences through brief synchronization, change-impact retrieval, and evidence-based diagnosis.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.