AI-Assisted Engineering:
Documenting the Agentic Workflow
An in-depth analysis of utilizing agentic programming tools, local hardware model clustering, and multi-agent loops to accelerate high-fidelity software development.
Introduction & Infrastructure Evolution
This project originated from a Coursera data science class where I sought to enhance my Python skills. It merges my interest in the biotechnology industry with the necessity of mastering state-of-the-art AI engineering tools. What began as simple scripting quickly evolved into a robust, autonomous development ecosystem.
My initial exploration began with the **Google Agentic Development Kit (ADK)** using evaluation credits. However, the free tier's rate limits and quotas proved restrictive. Upgrading to the paid tier quickly accumulated a $400 API bill due to massive recursive model queries.
The Local Transition: To optimize costs, I transitioned to running local LLM models (Qwen, DeepSeek, Mistral, and domain-specific variants) orchestrated via Ollama. This required a custom hardware upgrade: acquiring a pre-owned Dell enterprise server to run deep local inference loops completely free of external API tolls.
Google Antigravity IDE
An agent-centric variant of VS Code combining a standard code Editor with an interactive Agent Manager to control concurrent autonomous coders in real time.
Ollama Local Model Suite
Self-hosted models running on dedicated Dell hardware, eliminating rate limits and billing overhead during continuous multi-agent debugging sessions.
The "Plan-Before-Code" Protocol
Autonomous programming requires strict human guidance and contract-driven verification to avoid low-reliability "vibe coding" patterns.
1. Documents as Contracts
Maintaining structured documentation like `PRD.md`, `README.md`, and `SCHEMA.md` is paramount. The Product Requirements Document (PRD) acts as a strict contract with the agentic coder, specifying architectural standards, constraints, and test scenarios.
2. Plan Approval Phase
Before any code is altered, the agent must generate an Implementation Plan, Task Checklist, and Walkthrough. This plan requires manual review and approval. Code changes are never executed blindly.
3. Continuous Feedback
Features are tested recursively using automated suites. If syntax or compile errors arise, they are fed directly back into the loop. If an agent struggles, models are dynamically swapped to bypass cognitive deadlocks.
The 26-Agent Orchestration Suite
To solve tasks beyond standard deterministic scripts, I designed a network of 26 specialized AI agents. Each agent's behavior is explicitly documented in an `AGENT_
Data Parsing Agents
Autonomous parsers designed to ingest complex, unstructured sources—specifically SEC HTML reports, PDF financials, and clinical registry data—extracting key parameters.
Data Normalization Agents
Cross-referencing entities. Ties clinical trial sponsors to parent corporations, stock tickers, and clinical database unique keys to create clean databases.
Analytical Agents
Algorithmic assessors. Conduct detailed analysis, evaluate pipeline gaps, perform scientific calculations, and compare current findings with historical clinical benchmarks.
Code Review Agents
Automated quality control. Reviews code contributions module-by-module to ensure style standard compliance and proactively identify potential logic blocks.
Decision Synthesis Agents
The intelligence layer. Compiles inputs and reviews from all previous agent pools to synthesize final, structured investment decisions and high-value strategies.
agent.py
The central execution script orchestrating all 26 agent classes in concurrent, multi-threaded pipelines on local Dell servers.
Operational Block Diagram
Below is the exact diagram illustrating the flow of data through our agentic loop. Notice how the empirical research acts as the foundation, driving the autonomous project creation.
Programmatic Workflow Engine
Click on any node in the diagram below to explore the core objectives and safeguards of each phase.
💡 Interactive Workflow Explorer
Click on any step of the programmatic block diagram above to explore the detailed mechanics, objectives, and vibration mitigations in Jonah's autonomous engineering workflow.
Ecosystem Visualization
Below is the second workflow visual showing the local model interaction pipeline and visual data structure output.
Figure 2: The hardware-software interaction topology representing local model pipelines.
Conclusion & Future Outlook
In the current 2026 AI landscape, organizations can leverage extensive talent and "endless minds" to accelerate timelines and execute complex tasks autonomously. The paradigm of strict document-driven contracts and local model execution eliminates both "vibe coding" and excessive cloud resource bills.
By building an operational bridge between research/analysis and software development, this workflow ensures that every codebase is grounded in empirical facts, yielding high-probability, high-fidelity applications.