Eight Modules for an Agentic Dev System: Continuity, Verification, and Reuse
Most agent workflows treat a task as a one-shot prompt, leaving no way to resume after interruption or to trust that a verified result applies to the current target. This system shows how to attach state, evidence, and versioned methods to every action, making agentic development auditable and reproducible, which is a practical blueprint for any team building serious AI-assisted engineering pipelines.
A code change is not a single tool call. The system must answer how work resumes, what proves completion, and which practices are worth reusing. JD Cloud's design addresses this with eight logical modules, not microservices: the main Agent orchestrates tool use; rules and skills separate project knowledge from operational procedures; retrieval splits historical search, exact identifier lookup, and semantic intent search; task state uses file locks and optimistic versioning to prevent old progress from overwriting new progress; action policies bind decisions to precise fingerprints and fail closed in pre-execution hooks; evidence is graded from E0 observation to E5 outcome impact; and a method library versions reusable practices, counting only independent successes per content hash.
The system is implemented with local files, SQLite, Python, and Node.js CLIs, deliberately avoiding a unified workflow engine. The main Agent drives everything through a tool-call loop, reading context, executing actions, and validating results. A concrete walkthrough for fixing duplicate search results shows how the modules interlock: clarify the target, locate the responsibility, select a versioned method, execute with policy checks, verify business behavior with full assertions, and write back both progress and method feedback.
The design reuses optimistic concurrency, content hashing, explicit contracts, and hierarchical acceptance. Its main contribution is binding these mechanisms to real development objects, so state changes, execution policies, evidence levels, and method maturity are all verifiable. Still, the authors note that module existence or partial tests do not prove overall efficiency gains; long-term measurement remains necessary.
The system treats resumability and evidence binding as first-class concerns, not afterthoughts, which is a significant departure from most agent frameworks that only capture conversation history.
The method library's versioning and independent-key counting directly addresses a common failure mode where teams over-trust 'This method worked before' without accounting for semantic changes.
The false-block incident reveals a subtle trap in policy engines: authorization checks must distinguish between executing a dangerous action and merely describing it, which is a classic text-vs-execution ambiguity.
By routing the main Agent through a tool-call loop rather than a centralized workflow service, the system keeps orchestration flexible and local, though it places heavy responsibility on the Agent's semantic judgment.
The E0-E5 evidence ladder is a useful communication tool, but the article honestly notes that program gates cannot verify the authenticity of raw evidence or business semantics, so human oversight remains necessary.