A graph-based autonomous AI agent system that plans, executes, evaluates, repairs, and synthesizes complex tasks.
Dragonite is not a single LLM call.
It separates an autonomous workflow into explicit engineering components:
User Request
│
▼
Planner
│
▼
Task DAG
│
├──────────────┐
▼ ▼
Task A Task B
└──────┬───────┘
▼
Executor
│
▼
Critic
│
┌────┴────┐
│ │
Good Failed
│ │
│ Replanner
│ │
└────◄────┘
│
▼
Synthesizer
│
▼
Final Answer
- 🗺️ LLM-powered task planning
- 🕸️ Dependency-aware DAG execution
- ⚡ Parallel execution of independent tasks
- 🔧 Tool execution layer
- 🔄 Retry handling
- 🔍 Critic / quality-control stage
- ♻️ Replanning and repair flow
- 🧩 Shared LLM client architecture
- 💾 Memory layer
- 📊 Execution progress tracking
- 🔭 Logging and tracing
- 🔌 Google ADK integration
The repository contains an actual terminal recording of the working system.
request → planning → task execution → orchestration → evaluation → final output
Dragonite uses a modular orchestration architecture:
┌──────────────┐
│ User Request │
└───────┬──────┘
▼
┌──────────────┐
│ Memory │
└───────┬──────┘
▼
┌──────────────┐
│ Planner │
└───────┬──────┘
▼
┌──────────────┐
│ Task DAG │
└───────┬──────┘
▼
┌──────────────┐
│ Executor │
└───────┬──────┘
▼
┌──────────────┐
│ Critic │
└───────┬──────┘
│
┌──────────┴──────────┐
▼ ▼
Accepted Failed
│ │
│ ┌─────▼─────┐
│ │ Replanner │
│ └─────┬─────┘
│ │
└───────────◄─────────┘
│
▼
┌──────────────┐
│ Synthesizer │
└───────┬──────┘
▼
Final Answer
The system intentionally separates:
planning ≠ execution ≠ evaluation ≠ recovery ≠ presentation
This makes the workflow easier to reason about, extend, debug, and test than putting the entire process into one large agent prompt.
📐 Detailed design: architecture.md
Tasks are represented as nodes with dependencies.
For example:
research_A ──────┐
├──► compare ──► evaluate ──► recommend
research_B ──────┘
Independent tasks can execute concurrently while dependent tasks wait for their prerequisites.
The executor uses Python concurrency to execute ready independent tasks in parallel.
This provides a foundation for scaling workflows beyond strictly sequential execution.
Task failures do not necessarily terminate the entire workflow.
The executor supports configurable retry attempts with backoff.
Attempt 1
│
Failure
▼
Attempt 2
│
Failure
▼
Attempt 3
│
Success / Final Failure
Dragonite does not blindly trust the first generated result.
The critic can identify quality problems and feed repair information into the replanning process.
Execute
│
▼
Critic
│
├── Good ──────────────► Continue
│
└── Problem ─► Replan ─► Repair ─► Execute
Planner, executor, and synthesizer can use a shared configured LLM client.
Shared LLM Client
│
┌────────────┼────────────┐
▼ ▼ ▼
Planner Executor Synthesizer
This avoids unnecessary model-client duplication and keeps model configuration centralized.
| Technology | Purpose |
|---|---|
| Python 3.11+ | Core implementation |
| Google ADK | Agent/application ecosystem |
| LLM providers | Model execution |
| FastAPI | API/application infrastructure |
| Pydantic | Validation and configuration |
| ThreadPoolExecutor | Parallel execution |
| OpenTelemetry | Observability |
| python-dotenv | Environment configuration |
All pinned dependencies are documented in requirements.txt.
git clone https://github.com/kcsanjayj/Dragonite.git
cd Dragonitepython -m venv .venv
.venv\Scripts\Activate.ps1python3 -m venv .venv
source .venv/bin/activatepip install -r requirements.txtCopy:
.env_example
to:
.env
Then configure your required model/provider credentials.
python run_agent.pyAlternative:
python -m multi_tool_agent.cliSecrets are intentionally excluded from Git.
Use:
.env
for local credentials.
Use:
.env_example
to document required variables.
Never commit API keys, tokens, passwords, or private credentials.
Dragonite is a hands-on autonomous-agent engineering project, not a claim of AGI or a production-ready platform.
The project demonstrates practical understanding of:
- multi-agent orchestration
- DAG-based workflows
- dependency management
- concurrent execution
- LLM integration
- tool execution
- retries and failure handling
- quality control
- replanning
- memory
- observability
There are still important areas to improve before production deployment, including:
- broader automated tests
- stronger sandboxing
- persistent production-grade state
- systematic evaluation benchmarks
- security hardening
- CI/CD
- production monitoring
- stronger failure isolation
Those limitations are intentionally documented rather than hidden.
💡 The goal of Dragonite is not to claim that the system is perfect. The goal is to demonstrate that I can design, implement, debug, and explain a non-trivial AI-agent architecture.
- 📐
architecture.md— system architecture - 📦
requirements.txt— pinned dependencies - ⚙️
.env_example— configuration template - 🎥
docs/demo/— project demonstration - 📜
LICENSE— MIT License
Dragonite was built to explore what happens when an LLM application is treated as a software system rather than just a prompt.
The focus is on:
architecture → execution → failure handling → evaluation → recovery → observability
rather than simply generating a response from one model call.
MIT License.
See LICENSE.
Built by Sanjay as a hands-on exploration of autonomous AI-agent systems and Python engineering.
⭐ If you find Dragonite interesting, consider starring the repository.