In my previous piece, AutoML on Autopilot , we explored how automating machine learning workflows could strip away the repetitive grind of model selection and hyperparameter tuning. It was about making the machine work for us.
But as the landscape of Generative AI has shifted toward Agentic Workflows, the goal has moved from simple automation to true autonomy. This update to the project represents that leap.
TL;DR: What’s New?
If you’re looking for a quick breakdown of how the project has evolved from a linear script to a production-ready agentic framework, here are the highlights:
- Logic: Shifted from Linear Scripting to a sophisticated Multi-Agent Orchestration (Root + Sub-Agents).
- Reasoning: Evolved from Simple Prompting to a Built-in Planner with a dedicated 4096 “Thinking Budget.”
- Error Handling: Replaced Manual Debugging with Auto-Self-Correction via a robust 10-retry execution loop.
- Output: Moved beyond Model & Plots to a complete Production Package including FastAPI, Docker, and multi-cloud documentation.
- Organization: Transitioned from a Single Directory mess to Isolated Sessions stored under runs/{session_id}/.
The Core Shift: Why a “Framework” isn’t enough
The original concept focused on streamlining pipeline execution. However, that workflow still required a human-in-the-loop to handle data validation, library constraints, and deployment packaging.
The latest update changes this by integrating a reasoning layer that doesn’t just run code — it understands the architectural requirements of a production-ready ML system.
Key Upgrades & Differences
1. Hierarchical Multi-Agent Orchestration
We’ve moved away from a single script. The architecture now utilizes a Root Agent that acts as the supervisor, handling initial CSV validation and routing tasks to specialized Sub-Agents (Classification, Regression, etc.). This ensures that the agent handling your data is a specialist in that specific domain.
2. Deep Reasoning with “Thinking Budgets”
We’ve moved beyond simple prompt-response cycles. The system now utilizes a centralized BuiltInPlanner with an optimized 4096 thinking budget. This allows the agent to perform deep architectural reasoning before a single line of code is written, effectively acting as a Senior ML Automation Architect.
3. Engineering Rigor & Self-Correction
This update focuses on production-grade standards that were missing in the initial automation phase:
- Mandatory Error Recovery: A strict error_retry_attempts=10 policy. If the execution fails, the agent analyzes the traceback and self-corrects the code in real-time.
- Isolated Session Management: Every run is assigned a unique SESSION_ID, with all artifacts organized into a structured directory hierarchy (runs/{session_id}/).
4. Seamless Deployment Handover
The “Autopilot” journey now extends to the very edge of production. Once the model is trained, a Deploy Agent automatically generates a production-ready package.
Seeing it in Action
Using the updated framework is incredibly straightforward. Because the agents handle the complexity, your input remains conversational.
- Clone and Install:
git clone https://github.com/Rishav1996/PyCaretAgent.git
cd PyCaretAgent
uv pip install .
2. Launch the Web Interface:
adk web --port 8000
Final Thoughts
The transition from AutoML on Autopilot to the current PyCaretAgent update represents a shift from “Tools” to “Partners.” We are no longer just writing scripts to automate tasks; we are building autonomous architects capable of managing the entire machine learning lifecycle.
Explore the updated project and start your own autonomous runs here:
👉 GitHub: Rishav1996/PyCaretAgent
From Automation to Autonomy: The Evolution of AutoML on Autopilot was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.