Eight Modules for an Agentic Dev System: Continuity, Verification, and Reuse
Agent Development Work System: Design and Practice for Parallel End-to-End Development with Multiple Requirements
To have an Agent complete a modification, three questions still need answering: how does work resume, how is the result accepted, and how is experience reused?
"Fix duplicate search results and verify in staging."
Taking this requirement as an example, it seems like just a code change, but in practice a series of questions need answering: does deduplication happen in the final response or upstream in the candidate pool? Are the original order and fields preserved? After local tests pass, is the image running in staging actually the one corresponding to this change? If continuing in another session, where do you pick up?
These questions cannot be answered with a single tool call. They require the system to retain task state, define the scope of actions, and map test and runtime results to specific completion criteria.
This system is built around these requirements: the main Agent understands the goal and organizes tool calls; rules and retrieval provide context; task records save progress; action policies constrain execution; quality checks determine completion; and a method library records which practices have been validated under what conditions.
Below we first look at the overall structure, then gradually explain the implementation. The search deduplication example runs throughout and is woven into a complete flow in Section 10.
1. Overview: Eight Modules, What Problem Each Solves
The system is divided into modules M1-M8, but they are logical responsibilities, not eight independent microservices. The implementation relies mainly on local files, SQLite, Python, and Node.js CLI, with a large language model capable of tool calls organizing collaboration.
Figure 1: The main Agent connects knowledge, state, execution, and acceptance; state and method feedback are also organized and written back by it.
| Module | Problem Solved |
|---|---|
| M1 Main Agent | What is the current goal, and what should be checked or done next? |
| M2 Rules and Skills | What conventions does this project have, and how should such operations be performed? |
| M3 Context Retrieval | Where are historical clues and current source code, and how to return to the original text? |
| M4 Task State | How far has the work progressed, and how to resume across sessions and concurrent updates? |
| M5 Tools and Platform Adaptation | How to apply operations to repositories, tests, and enterprise platforms? |
| M6 Action Policy | Does executing this operation for this specific goal fit the scope and authorization? |
| M7 Evidence and Quality | What can existing results prove, and what is still missing to complete the task? |
| M8 Method Governance | Which experiences can be reused, and how to revalidate after method revisions? |
These modules are not a pipeline that must be traversed sequentially. The main Agent reads M2, M3, M4, M8 as needed, organizes policy checks, tool execution, and acceptance, then writes progress back to M4 and actual reuse results back to M8.
2. M1 Main Agent: Understand the Goal, Then Organize Tool Calls
"Fix duplicate search results" does not directly tell the system where to modify.
Duplicates in the final response, upstream candidate pool, or a specific display module may correspond to different responsibility locations. The main Agent first must understand which layer of the problem the user wants solved, then decide which repository to read, which call chain to inspect, and which verification method to use.
Retrievers can return matching source code, and state programs can save current progress, but they do not replace this layer of business judgment.
M1's execution method is a tool call loop:
Read user goal and current state
↓
Choose information or execution tool
↓
Construct arguments and call tool
↓
Read results, errors, and evidence
↓
Continue / correct / wait / accept
Planning, implementation, and evaluation can be done sequentially by the same main Agent. Only when a task has an independent work boundary and introducing a separate role is authorized, are other executors or reviewers arranged. Role names themselves do not constitute independent review guarantees.
Cross-module orchestration currently occurs mainly in this tool call loop; there is not yet a unified background workflow service that automatically advances all steps.
3. M2 Rules and Skills: Separate Project Knowledge from Operational Procedures
M2 answers two questions: how does this project work, and how are such operations performed.
These two types of knowledge are related but should not be mixed. Delivery processes can be reused, while project parameters such as application names, target branches, and instance groups need separate maintenance.
Therefore, operational knowledge is organized into three levels:
Global conventions / Project AGENTS.md
General rules, project boundaries, verification methods
Project technical map
Entry points, module responsibilities, call chains, common commands
Skill directory
SKILL.md purpose, trigger conditions, operation steps
scripts/ executable programs
references/ parameters, templates, complex flow details
assets/ resources needed for operations
For example, a delivery Skill explains how to select a repository execution contract, call the build interface, read artifacts, and run probes; the contract provides the specific parameters and execution requirements for that project. This way, adjusting application parameters does not require rewriting the general process, and updating the process does not require reorganizing all project details.
Loading is also on-demand: first identify resource purpose, read content when applicable, and expand necessary references during execution. This corresponds to Agent Skills' metadata discovery, content activation, and on-demand resource loading.
M2 organizes rules and operational resources; whether a practice is applicable, how many times it has been verified, and whether it remains reliable after modifications are managed by M8.
4. M3 Context Retrieval: Choose Paths Based on Missing Information
Looking up historical discussions, finding a known field, and locating an entry point when only its function is known are three different problems. M3 retains three retrieval paths for them instead of sending all queries to vector retrieval.
Figure 2: First determine what information is missing, then select the retrieval method; after finding candidates, still need to return to the current source for verification.
4.1 Historical Search: Python + SQLite FTS5
When needing to answer "where was this discussed or handled before," use historical retrieval.
A Python importer reads append-only session records and writes messages and summarized snippets into a local SQLite database. It saves the byte offset of the source file and continues from that position next time; an incomplete line at the end is left for later processing. Each record retains project, session, time, source file, and offset to locate the original text.
Queries use FTS5 and BM25, and support filtering by project and other scopes. For short queries or full-text search anomalies, a LIKE fallback is provided. The usage order is: first use search to find candidates, then timeline to inspect adjacent context, and finally show to read the original text.
There are two limitations to remember: hot indexing skips large tool payloads, so a miss does not mean the action was never executed; historical records also cannot prove today's branch, configuration, or runtime state, so current facts still need to be read from current sources.
4.2 Finding Known Identifiers: ripgrep
When you already know a class name, field, error string, or configuration key, directly use rg for text, regular expression, or file enumeration.
For example, looking up expected_revision, finding its definition and callers first is more direct than re-describing its function and doing semantic retrieval. After matching files and line numbers, inspect the call chain to confirm it is within the responsibility scope of the current issue.
4.3 Finding Unknown Entry Points: Node.js + Local Model + Zvec
When only the function is known and not the entry name, use semantic-context.mjs. This path is implemented as follows:
Specify root and positive globs (file patterns included in retrieval)
↓
Enumerate files, record file hashes and range snapshots
↓
zg 0.2.1 extracts text snippets, incrementally refreshes by range
↓
Transformers.js loads local ONNX model
multilingual-e5-small / 384 dims / CPU
↓
Zvec vector index, zg context returns candidates
↓
Read original source lines back, verify range snapshots
zg supports combined lexical and vector candidates. The local adapter calls its public index and context API, fixes the local model, disables remote downloads and network fallbacks, and does not build a separate remote vector service. Indexes are isolated by normalized directory, file pattern, and model, stored outside the source tree, and can be rebuilt.
This path not only returns similar snippets but also preserves three types of info: path, startLine, endLine for locating original text; sha256, sourceSnapshot for identifying provenance; and matchedBy, contentTruncated for describing match and truncation status.
Before returning, it checks again for file additions, deletions, and content changes to avoid treating drifted snapshots as valid results. However, both model input and output snippets may be truncated, so candidates still do not guarantee complete coverage.
This adapter path is currently under bounded trial: max 200 files, 256 KiB per file, 4 MiB total; exceeding limits narrows the scope. These are local trial limits, not general limits of the underlying tools; there is no background full scan or mandatory run per task.
Use existing information directly; retrieve only when information is missing. Reusable method retrieval belongs to M8 and is not mixed with source code indexing here. Also, E5 here is the embedding model name, unrelated to the E5 evidence level in Section 8.
5. M4 Task State: Both Resume and Prevent Old Progress from Overwriting New Progress
When resuming work across sessions, the most important thing to restore is not the entire chat but four things: what the goal is, what has been confirmed, what evidence is still missing, and what to do next.
workctl.py stores this information in tasks/*.md. Task files are authoritative records: a structured header stores task_id, revision, status, owner, and update time; the body records goal, evidence, gaps, blockers, and next steps. Overviews are generated programmatically.
Below is a field and content illustration, not the complete task file format:
task_id: task-…
revision: 7
status: validating
Goal: Fix duplicates in final response and complete staging verification
Confirmed: Local complete output and preservation conditions pass
To prove: Result of current staging image processing a fixed request
Next: Read back instances, then send business probe
Saving state also needs to handle another issue: what if two updaters both have old progress?
Assume A and B both read revision = 7. A commits first, the task becomes version 8; B then submits still carrying expected_revision = 7 and is rejected. B must re-read the latest record and decide how to merge its own update.
File locks coordinate the write process; version checks prevent old state from overwriting new state. The two solve different problems.
Figure 3: Acquire lock, read, compare version, then write new state; on conflict, keep the original record and let the updater re-read.
The specific write order is: acquire flock file lock, read task and compare expected_revision, write temporary file, execute flush / fsync, atomically replace, then update derived overview. Atomic replacement reduces the risk of half-files; these mechanisms are limited to local records and do not provide distributed transactions or idempotence for remote actions.
When resuming work, the Agent first checks whether the goal has changed, then continues from the gap; when historical clues are needed, it calls M3. Subsequent execution can be triggered by continued user conversation or configured scheduled tasks, but scheduling configuration and actual run results must be verified separately; a trigger does not mean the business is complete.
5.1 Requirement Cards: Connecting Multiple Tasks into One Requirement
Task cards record progress on one piece of work, but a requirement may span multiple tasks, sessions, projects, or Agents.
reqctl.py, added on 2026-09-17, adds this layer with requirement cards. The authoritative record is requirements/req-*.md, centrally linking the following objects:
Task cards which tasks are advancing this requirement
Sessions which hosts, Agents, and sessions participated
Feature modules pending → in_progress → done → verified
Dev branches which branch completed which modules
Issue records open → resolved / workaround, with resolution method
Methods reused methods and their content version hashes
Evidence and docs evidence references, reference docs
Phase advancement discovering → developing → validating
→ delivering → observing → closed
When resuming, start from the requirement card to find related tasks, branches, and issues, then read specific records to continue. Requirement cards and task cards use the same file lock, optimistic version check, and atomic write protocol; both are updated programmatically, and derived indexes are read-only.
6. M5 Tools and Platform Adaptation: Applying Operations to Real Systems
After understanding the goal and saving state, the next step is actually modifying code, building artifacts, deploying, and verifying. M5 connects these actions to local repositories, test tools, and enterprise platforms.
A typical call chain is below:
Main Agent / domain Skill
↓
Delivery driver: composes Git, build, deploy, verify steps
↓
Python operation wrappers: covered platform atomic operations
↓
Node.js CLI tool with manifest pinning
↓
Platform adapters and standard communication interfaces
Project routing selects the repository and delivery driver, and the repository execution contract provides parameters such as application, branch, commit, instance group, image, probe ID, query scope, and result constraints.
Another guarantee here: the entry point for checking is the entry point that actually runs. Therefore, the runtime package, entry point, and adapters are pinned via a runtime manifest and SHA-256, and are re-read and verified in the execution chain.
| Work Category | Tool & Platform Path | Returned Capabilities & Materials |
|---|---|---|
| Code & Delivery | Git, delivery driver, delivery platform | Branch operations, builds, artifact identities, staging delivery |
| Runtime & Business Verification | Log platform, config center, business verification platform | Config & runtime read-back, business probes, raw responses |
| Data & Experiments | Data platform, experiment platform entries | Scoped queries, experiment operations, return verification |
| Extended Capability Discovery | Capability catalog & app metadata paths | Capability schema discovery and specific interface selection |
Each adapter declares capabilities based on actual verification scope. Capability discovery does not mean every operation has been accepted; each entry point retains its own parameter and scope checks.
M5 returns structured results, errors, artifact identities, and raw evidence. The workflow integrates M6 before actions and passes to M7 for acceptance after execution. On timeout or lost response, first read back the remote state, then decide whether to retry, rather than defaulting to executing again.
7. M6 Action Policy: Being Able to Call Tools ≠ Having the Authority to Execute Actions
The host allowing Bash does not mean a specific deployment, deletion, or outbound message is already authorized for business.
M6 checks specific actions. Non-production operations that are in scope, environment-clear, and recoverable can proceed if they satisfy the policy's positive target schema (allowed target structure) and the operation contract. Production or unknown-environment changes, destructive operations, permission and credential changes, outbound messages, payments, etc., require explicit authorization for the corresponding action.
7.1 Binding Specific Actions with Fingerprints
authzctl receives action type, stable scope ID, precise target, and operation, and returns decision, reason, and an action fingerprint based on a JSON policy.
The fingerprint is computed as follows. This is illustrative, not a runnable complete Python program:
contract = {
"action": action,
"scope_id": scope_id,
"target": target,
"operation_kind": operation_kind,
"operation": operation,
"resource": resource,
"allowlist_id": allowlist_id,
"policy_sha256": policy_sha256,
}
fingerprint = sha256(canonical_json(contract))
Canonical JSON fixes key order and separators so the same action description gets a stable fingerprint. Any change in target, parameter, or policy changes the fingerprint.
For example, after a merge creates a new commit, build and deploy must bind to the new object, not reuse a vague "release it." Fingerprints bind the action description; authorization still requires the corresponding policy and user confirmation process.
Figure 4: Policy decision binds to the specific action; re-evaluated when target, parameter, or policy changes. The diagram shows policy-execution relationship, not that all tool types are already intercepted.
7.2 From Explicit Calls to Host Pre-execution Interception
Earlier, action policy relied on workflows explicitly calling it before execution. Later, a host's pre-execution hook was integrated for inspection, using a fail-closed approach for policy-covered commands: if the allow condition is not met, the command is not executed.
In execution entry points already wired into the policy, commands requiring explicit authorization must complete the corresponding decision and authorization before proceeding.
Blocked commands must first undergo policy evaluation, obtain explicit user authorization for the precise action, target, and operation, and then register an authorization record. The authorization record is bound to the command and action fingerprint; if the actual operation changes, re-evaluate and obtain the corresponding authorization.
7.3 One False Block: Even the Command for Recording the Issue Was Blocked
Wiring verification exposed a real defect: the interceptor first blocked a verification command containing dangerous operation descriptions, then blocked the record command "log this blocked command into the requirement card."
The reason: the record command's arguments also contained the same text. The description of the dangerous operation triggered the check, so both authorization and logging paths were blocked together.
The fix introduced restricted handling rules for the recording and authorization paths, and added related execution checks. The problem and fix were both recorded in the requirement card. This case shows that interception design needs to distinguish the operation actually being executed from ordinary text describing the operation.
Coverage boundary: The effective scope of the policy depends on the actual wiring and validation of each execution entry point. Passing classification tests does not prove all execution paths are covered; each entry point must be verified individually.
8. M7 Evidence and Quality: After Execution, How to Prove Completion
Code tests passing only answer whether those tests pass. They do not directly answer: what image is running in staging, what configuration is used, and whether real business requests are correct.
M7 maps execution materials to task requirements, distinguishing "what has been done" from "what has been proven."
8.1 Defining How Far Conclusions Can Reach with E0-E5
This system uses the following evidence levels:
| Level | Question to Answer | Typical Materials |
|---|---|---|
| E0 Observation | What symptoms appeared? | User feedback, historical records, unverified observations |
| E1 Code | What behavior does the current source or local artifact have? | Source, diffs, full behavior tests, local artifacts |
| E2 Config & Data | What configuration and data were actually selected? | Experiment assignment, config read-back, indexes, caches, datasets |
| E3 Runtime State | What exactly is currently running? | Immutable artifacts, instance and Provider binding |
| E4 Business Acceptance | Does the current target handle real business requests correctly? | Full fields, content, order assertions, and relevant negatives |
| E5 Outcome & Impact | Did performance, reliability, cost, or business improve? | Predefined metrics, populations, windows, baselines or controls |
Not all tasks need to reach E5. Documentation changes can be accepted with local evidence; staging delivery must verify the corresponding target's business behavior; tasks requiring outcome improvement need corresponding outcome evidence.
Evidence must also bind to the target. Passing business verification for image A does not directly vouch for image B. After a target change, old records are kept, but affected configuration, runtime state, and requests must be re-verified. Request patterns, callers, data, and time also affect whether evidence can be reused.
8.2 Integrating Acceptance Requirements into the Task Closure Entry
quality.json stores quality contracts: original requirements, responsibility boundaries, minimal necessary design, assumptions, goals, behavior tests, and delivery checks.
quality_gate.py checks whether fields are complete, whether there are unverified implementation assumptions, whether tests correspond to the target, and whether delivery evidence required by the task scope is missing.
For tasks registered with quality_contract and quality_target, workctl calls the closure check before writing closed or observing_outcome. If the check fails, the task and revision remain unchanged; if it passes, the check contract hash is saved and the corresponding status update is allowed.
Figure 5: Registered tasks enter the closure check; failures keep the original state, unregistered old tasks still follow the compatibility path.
Evidence levels are acceptance specifications; program gates are executable checks. The two cannot be conflated. Unregistered old tasks still follow the compatibility path; program checks structure and consistency but cannot replace review of raw evidence authenticity and business semantics.
8.3 Outcome Metrics Must Be Defined Before Seeing Results
When requiring E5, specify the metric formula, observation population, complete window, data source, baseline or control, owner, stopping condition, and causal limitations in advance.
You cannot first pick a good-looking result and then work backwards to define success. Business request passing and outcome improvement are two different conclusions.
9. M8 Method Governance: Experience Can Be Reused, But Success Records Cannot Be Inherited Arbitrarily
The method library must not only save "how it was done before," but also answer: is this applicable, which version is being executed, has success been verified, and are there counterexamples.
methodctl.py manages such records. The authoritative data is library/*.json, methods/*.md is the reading view, and registry and INDEX are derived indexes. A method contains four groups of information:
Applicability: trigger / scope / prerequisites / exclusions
Execution: decision / procedure / each step's action, check, stop_if
Acceptance: outcome_class / outcome / closure_gate / safety_boundaries
Feedback: evidence / cases / status / revision
The "learning" here occurs in the external method library, work context, and execution constraints, not involving online training of model weights. Retrieval influences next practice choice, and execution feedback changes the method's maturity and applicability conditions.
9.1 Find Candidates First, Then Judge Adoptability
M8 uses lexical matching, separate from M3's source code vector retrieval. English and identifiers extract tokens; consecutive Chinese is split by adjacent bigrams; then matched against method titles, summaries, domains, trigger conditions, goals, scope, and keywords.
Scoring rules are:
coverage = matched query tokens / total query tokens
score = 10 × coverage + maturity_bonus
stable = 4,draft = 3,candidate = 2,needs_review = 1
Retrieval first filters by domain and status, returns no results on zero hits, then sorts by score and title. --explain returns matched words, content version, trigger conditions, prerequisites, exclusions, and thresholds for the main Agent to judge.
Relevance only means worth checking, not directly adoptable. Whether the method's prerequisites are satisfied still needs to be judged against the current task.
9.2 When a Method Changes, Why Old Successes Cannot Keep Being Counted
A counterexample test illustrates this well: the old version has succeeded three times, the new version only once, yet the old implementation still judged the method as stable.
After the fix, the new version is judged as candidate, and all four historical records are retained. Changing the independent key of an old case cannot bypass content-version matching.
To achieve this, method selection, execution, and feedback must be connected.
Bind version at selection. contract_hash computes SHA-256 over semantic fields like trigger conditions, prerequisites, scope, steps, exclusions, completion thresholds, and safety boundaries. Before execution, save method_id + contract_hash + fit, indicating which step is being reused and how it will be verified. Keywords, summaries, accounting times, and other metadata are separated from content identity.
Bind actual results at feedback. Register success, partial, failure, or contradiction, along with target, evidence type, and level. Results correspond to the version selected before execution; you cannot post-hoc sign old experiences with the current hash.
Count independence when tallying. independent_key distinguishes independent tasks. Multiple probes, fix retries, and different stages of the same event cannot be split into multiple independent successes.
Re-accumulate after semantic revision. Old cases remain, but cannot increase the new version's maturity; unresolved failures or contradictions block upgrades.
Figure 6: First bind version, then execute validation and feedback; cases are counted by content version and independent task.
Current project rules: one independent verified success of the same content version is candidate, two is draft, at least three with no unresolved failures or contradictions is stable; if failures or contradictions appear, it enters needs_review first.
Success must also meet the threshold declared by the method. Outcome methods require E5; with only E4 delivery evidence, it is recorded as partial and not a full success for that method.
Old library cases without binding still have a compatibility path, but cannot boost the new version's maturity after semantic revision. Content hashes also cannot prove evidence authenticity, that independent keys are truly independent, or that overall success was caused by this method.
10. Complete Run: How a Search Deduplication Request Goes Through
Back to the teaching example at the start: fix duplicates in the final search response, preserve the first occurrence order and original object fields, and verify in staging. This is used to illustrate module collaboration, not a new actual execution record.
Figure 7: From goal clarification to business acceptance, then state and method feedback; actual steps are organized by the main Agent as needed.
First clarify the goal. M1 and M2 confirm the problem is in the final response, and write down preservation conditions such as order and fields. M4 creates task records; when multiple tasks are involved, they are aggregated through requirement cards.
Then locate responsibility. Use rg for known fields or errors; use intent retrieval when only the function is known; query history to learn about past handling. After M3 returns candidates, still read the current source and call chains.
Select reusable methods. M8 provides relevant practices, M1 checks prerequisites and exclusions. After deciding to adopt, first bind method ID, content hash, and verification plan, then execute.
Modify and deliver. Access M6 for action scope determination, and M5 completes code changes, tests, builds, and delivery. Artifact identities and platform returns must be preserved; operations like merges change the commit, so subsequent targets must be updated.
Verify complete business behavior. For the input below, acceptance cannot only check result count:
Input: [P1, P1, P2]
Expected: [P1, P2]
Check: whether identities are correct, whether first occurrence order is preserved, whether object fields are preserved.
Only asserting "count equals 2" would miss [P2, P1] or misbound titles. First verify complete local behavior, then verify staging configuration, runtime target, and corresponding business requests; M7 determines whether the original requirements are met. If the target changes, add affected evidence.
Finally write back progress and method results. Unfinished gaps and next steps go into M4; when conditions are met, update status through the corresponding closure check. Actually reused methods are fed back to M8 with the selected version, independent key, and evidence; failures and partial successes must be retained too.
This chain relies on the main Agent's tool calls, task records, and evidence references, not driven automatically by a unified message bus. The model handles semantic judgment; programs execute computable constraints.
11. Impact on Work: What Artifacts Are Visible
The system's impact can be seen through three kinds of verifiable artifacts.
Resuming work has a clear entry. Historical retrieval retains original clues, task cards save goals and gaps, requirement cards link tasks, sessions, modules, branches, and issues. When entering unfamiliar code, there is also a project technical map, current files, and responsibility chains to check.
Execution and acceptance have corresponding materials. Staging delivery preserves artifact identity, configuration and runtime read-back, business responses; actions have scope determination, completion has corresponding checks, not just a "execution successful" message.
Reusing experience has versions and counterexamples. Methods have applicable steps, content contracts, and validation cases. Practices no longer applicable enter review; revisions keep old records, and new versions re-validate.
These mechanisms provide work support, but cannot infer total hours saved or long-term accuracy improvements solely from module existence or partial tests. Efficiency and effectiveness still need continuous measurement in real tasks.
12. Technical Characteristics and Relationship with Existing Solutions
This system reuses engineering ideas such as optimistic concurrency, content hashing, explicit contracts, hierarchical acceptance, and traceable feedback. Its focus is not to replace a certain framework but to connect these mechanisms to specific development objects and execution entry points.
12.1 How They Combine with Existing Mechanisms
The table below compares capability levels, not functional rankings, and does not represent benchmark under equivalent conditions.
| Solution / Mechanism | Reference Capability | Our System's Focused Combination |
|---|---|---|
| Agent Skills | Standard directory encapsulating knowledge, scripts, and resources, loaded on demand | Beyond resource organization, manage method applicability conditions, versions, and validation cases |
| LangGraph Persistence | Checkpointer saves thread graph state, store saves cross-thread data | Beyond state persistence, define acceptance identity for environment, artifacts, config, and requests |
| Temporal Workflow | Event history and replay recovery | Beyond execution recovery, domain contracts define business evidence and completion conditions |
| LangSmith Evaluation | Datasets, evaluators, offline/online evaluation, failed case regression testing | Beyond evaluation, track content versions, independence, and counterexamples across tasks |
| Claude Code Hooks | Pre-tool-use allow, deny, or ask user | Carries action policy; the Bash command-level check described here is in wired hosts |
These mechanisms can extend and combine; the table distinguishes concerns, not functionality gaps.
12.2 Three Design Choices Running Throughout
First, carry target identity through acceptance. Source, commit, config, image, request, and evidence need to correspond. If the target changes, do not directly reuse conclusions from the old target.
Second, bind method feedback to the version at execution time. Select version first, record results later; semantic changes restart accumulation, failures and contradictions cannot be drowned by success counts.
Third, connect computable rules to actual entry points. Version conflict checks enter the state write flow, quality checks enter the closure flow for registered tasks, Bash policy enters the pre-execution hook of wired hosts. Constraints that can be checked by programs are not left to the Agent's memory of a paragraph.
12.3 What Still Needs Verification
Future work includes expanding policy coverage at the API and deployment adapter level, verifying actual wiring on different hosts, and continuously observing long-term effects and cross-team migration.
Internal instruction simplification has a separate experiment, not expanded here, so it is not used as evidence of effectiveness. These designs also do not constitute proof of algorithmic originality or comprehensive leadership.
Back to the original question: after completing a code change, can the system still explain how far it has gone, what is running, basis for acceptance, and whether this experience can be used next time?
This is exactly the goal of the eight modules: main Agent organizes work, rules and retrieval provide context, state carries progress, tools implement operations, policy constrains actions, quality corresponds to evidence, and method governance records validated practices.