Spaces:
Running
🤖 Autonomous Python Coding Agent
A production-grade, self-healing multi-agent pipeline that doesn't just generate Python code — it autonomously writes, validates, tests, secures, benchmarks, and reflects on its own output before shipping.
🚀 Live Demo
▶ Try it on Hugging Face Spaces
📸 Demo
🔥 What makes this different from just using ChatGPT?
| Feature | ChatGPT / Basic Agent | This Agent |
|---|---|---|
| Code generation | ✅ | ✅ |
| Syntax validation | ❌ Run and hope | ✅ AST parse before running |
| Test cases | ❌ Manual | ✅ Auto-generated by agent |
| Stress testing | ❌ | ✅ 500+ random inputs via Hypothesis |
| Memory | ❌ Stateless | ✅ ChromaDB learns from past bugs |
| Security audit | ❌ | ✅ Detects eval, exec, hardcoded keys |
| Performance check | ❌ | ✅ Benchmarks 1000 runs, rejects slow code |
| Self-review | ❌ | ✅ Agent scores own confidence 1-10 |
| Self-healing | ❌ | ✅ Loops back and fixes failures automatically |
| Separate retry counters | ❌ | ✅ Per-node counters prevent pipeline blockage |
📊 Key Metrics
| Metric | Value |
|---|---|
| Pipeline nodes | 13 |
| Verification layers | 5 (AST → Tests → Hypothesis → Security → Complexity) |
| Max retries (debugger) | 3 |
| Max retries (security, complexity) | 2 each — independent counters |
| Hypothesis test cases | 500+ random inputs per run |
| Benchmark iterations | 1,000 runs |
| Performance threshold | < 5ms per call |
| Memory backend | ChromaDB vector similarity search |
| LLM | Llama 3.1 8B Instant via Groq |
| Avg pipeline runtime | ~20–40 seconds |
| Lines of code | ~600 across 5 files |
🏗️ Architecture — 13-Node Pipeline
User Input (Python Task)
│
▼
┌─────────┐
│ Planner │ ── Breaks task into blueprint
└────┬────┘
│
▼
┌───────┐
│ Coder │ ── Writes code using plan + ChromaDB memory
└────┬──┘
│
▼
┌───────────────┐
│ AST Validator │ ── Syntax + hallucinated imports + type hints
└──────┬────────┘ (no execution needed — milliseconds)
│
Pass │ Fail ──► Debugger ──► back to AST
▼
┌────────────────┐
│ Test Generator │ ── Auto-generates pytest-style test cases
└───────┬────────┘
│
▼
┌────────┐
│ Tester │ ── Runs code + generated tests in sandbox
└───┬────┘
│
Pass │ Fail ──► Debugger (max 3 retries)
▼
┌────────────┐
│ Hypothesis │ ── 500+ random inputs, property-based testing
└─────┬──────┘ (never blocks pipeline — informational only)
│
▼
┌───────────┐
│ Benchmark │ ── Runs 1000x, rejects if > 5ms/call
└─────┬─────┘
│
▼
┌──────────┐
│ Security │ ── Detects eval/exec/hardcoded secrets
└─────┬────┘ (own retry counter — max 2)
│
▼
┌────────────┐
│ Complexity │ ── Line count + nesting depth + LLM score/10
└──────┬─────┘ (own retry counter — max 2)
│
▼
┌─────────────────┐
│ Self Reflection │ ── Agent scores own confidence 1-10
└────────┬────────┘ Rewrites if confidence < 7
│
▼
┌──────────┐
│ Reviewer │ ── Polishes + docstrings + type hints
└─────┬────┘
│
▼
┌──────────┐
│Explainer │ ── Writes human-readable explanation
└─────┬────┘
│
▼
OUTPUT
Final Code + Explanation
📁 Project Structure
autonomous-coding-agent/
├── app.py ← Streamlit UI
├── main.py ← Graph builder + entry point
├── state.py ← Shared TypedDict state (whiteboard)
├── nodes.py ← All 13 node functions + LLM + ChromaDB
├── edges.py ← All 7 conditional route functions
├── requirements.txt ← Dependencies
└── README.md
⚡ Run Locally
Prerequisites
- Python 3.11+
- Groq API key — get free at console.groq.com
Step 1 — Clone the repo
git clone https://github.com/krishpatel/autonomous-coding-agent.git
cd autonomous-coding-agent
Step 2 — Create virtual environment
python -m venv venv
# Mac/Linux
source venv/bin/activate
# Windows
venv\Scripts\activate
Step 3 — Install dependencies
pip install -r requirements.txt
Step 4 — Set your API key
# Mac/Linux
export GROQ_API_KEY=your_groq_api_key_here
# Windows
set GROQ_API_KEY=your_groq_api_key_here
Or create a .env file:
echo "GROQ_API_KEY=your_groq_api_key_here" > .env
Step 5 — Run CLI (no UI)
python main.py
Step 6 — Run Streamlit UI
streamlit run app.py
Open http://localhost:8501 in your browser.
🐳 Run with Docker (optional)
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8501
CMD ["streamlit", "run", "app.py", "--server.port=8501"]
# Build
docker build -t coding-agent .
# Run
docker run -e GROQ_API_KEY=your_key -p 8501:8501 coding-agent
🌐 Deploy to Hugging Face Spaces
# Install HF CLI
pip install huggingface_hub
# Login
huggingface-cli login
# Create space and push
huggingface-cli repo create autonomous-coding-agent --type space --space_sdk streamlit
git remote add hf https://huggingface.co/spaces/YOUR_USERNAME/autonomous-coding-agent
git push hf main
Then add your secret in HF Spaces Settings:
GROQ_API_KEY = your_key_here
🛠️ Tech Stack
LangGraph — Stateful multi-agent graph orchestration
Groq API — LLM inference (Llama 3.1 8B Instant)
ChromaDB — Vector database for bug fix memory
Hypothesis — Property-based stress testing
Streamlit — Production UI
subprocess — Sandboxed isolated code execution
ast — Static code analysis without execution
hashlib — Deterministic ChromaDB IDs
importlib — Real-time import hallucination detection
💡 Key Engineering Decisions
Why LangGraph over plain LangChain?
LangGraph handles cyclic workflows — when tests fail, the agent loops back through the debugger and restarts verification from AST. LangChain's linear chains can't do this cleanly.
Why AST validation before running?
Running broken code wastes subprocess time. AST parsing catches syntax errors in milliseconds without execution — like a proofreader checking spelling before printing.
Why Hypothesis for testing?
Hand-written tests only cover cases you think of. Hypothesis auto-generates 500+ random inputs and verifies properties that should always hold. Catches edge cases no human would write.
Why separate retry counters per node?
One shared counter caused security failing 3 times to kill the entire pipeline before the debugger got its attempts. Separate counters for security and complexity mean each node fails independently without blocking others.
Why hashlib instead of Python's hash()?
Python's hash() is randomized every session for security. Same error → different ChromaDB ID → agent can never retrieve past fixes. hashlib.md5 is deterministic across all sessions.
Why combined Reviewer + Explainer?
Two separate LLM calls for polishing and explaining wasted ~8 seconds. One combined call with structured output (FINAL_CODE: / EXPLANATION:) saves an entire API round trip.
🐛 Real Bugs Found and Fixed
Bug 1 — False Positive in Tester
returncode == 0 doesn't mean the function was called. A file that only defines functions exits successfully but prints nothing. Fixed by checking stdout is not empty after successful run.
Bug 2 — ChromaDB Hash Randomization
Python's hash() is session-randomized. Same bug → different ID every run → memory retrieval never works. Fixed with hashlib.md5().hexdigest()[:8] for deterministic cross-session IDs.
Bug 3 — Python 3.11 F-string Backslash Python 3.11 doesn't allow backslashes inside f-string expressions. Benchmark node embedded code inside f-strings. Fixed using string concatenation instead.
Bug 4 — Shared Retry Counter
One retries counter shared across all nodes caused security/complexity failures to consume the debugger's retry budget. Fixed by adding security_retries and complexity_retries as independent counters.
🔑 Environment Variables
| Variable | Required | Description |
|---|---|---|
GROQ_API_KEY |
✅ Yes | Get free at console.groq.com |
GITHUB_TOKEN |
❌ No | Only needed for AutoReview AI project |
📝 Resume Line
Autonomous Python Coding Agent | LangGraph · Groq · ChromaDB · Streamlit Built a 13-node self-healing pipeline with 5-layer verification — AST validation, auto-generated tests, Hypothesis property testing (500+ random inputs), security audit, and self-reflection confidence scoring. ChromaDB vector memory enables cross-session bug fix learning. Deployed on Hugging Face Spaces.
👨💻 Author
Krish Patel — AI Engineer
GitHub · LinkedIn · Live Demo
Built as part of AI Engineer internship portfolio — Bangalore, 2026