┌─────────────────────────────────────────┐
│              ORCHESTRATOR               │
│         (Python + LangGraph)            │
│              $0/month                   │
├──────────┬──────────┬───────────────────┤
│  LLM 1  │  LLM 2   │    LLM 3         │
│ Claude  │ GPT-4o   │   Gemini Pro     │
│ $20/mo  │ $20/mo   │   $7/mo          │
├──────────┴──────────┴───────────────────┤
│           TOOL LAYER                    │
│   Terminal │ File System │ Browser      │
│   Git │ Docker │ npm/pip │ Linting      │
├─────────────────────────────────────────┤
│          KNOWLEDGE BASE                 │
│   Project docs │ Style guide │ Tests    │
│              $0/month                   │
└─────────────────────────────────────────┘

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    task: str
    context: str
    model_used: str
    code_output: str
    test_results: str
    iteration: int
    messages: Annotated[list, operator.add]

def route_task(state: AgentState) -> str:
    """Route to the best model based on task type."""
    task = state["task"].lower()

    if any(w in task for w in ["refactor", "optimize", "clean", "improve"]):
        return "claude"  # Claude excels at code quality
    elif any(w in task for w in ["test", "debug", "fix", "error"]):
        return "gpt4o"   # GPT-4o is great at debugging
    elif any(w in task for w in ["document", "explain", "summary"]):
        return "gemini"  # Gemini for documentation
    else:
        return "claude"  # Default for generation

def should_iterate(state: AgentState) -> str:
    """Decide if we need another iteration."""
    if state["iteration"] >= 3:
        return END
    if "PASS" in state.get("test_results", ""):
        return END
    return "generate"

import anthropic
import openai
import google.generativeai as genai

class ModelRouter:
    def __init__(self):
        self.claude = anthropic.Anthropic()
        self.gpt = openai.OpenAI()
        genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
        self.gemini = genai.GenerativeModel("gemini-1.5-pro")

    def generate(self, model: str, prompt: str, context: str = "") -> str:
        if model == "claude":
            response = self.claude.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=4096,
                messages=[{"role": "user", "content": f"{context}\n\n{prompt}"}]
            )
            return response.content[0].text

        elif model == "gpt4o":
            response = self.gpt.chat.completions.create(
                model="gpt-4o",
                messages=[{"role": "system", "content": context},
                         {"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

        elif model == "gemini":
            response = self.gemini.generate_content(f"{context}\n\n{prompt}")
            return response.text

import subprocess
import os
from pathlib import Path

class DevTools:
    """Tools the agent can use to interact with the codebase."""

    def read_file(self, path: str) -> str:
        """Read a file from the project."""
        return Path(path).read_text()

    def write_file(self, path: str, content: str) -> str:
        """Write content to a file."""
        Path(path).parent.mkdir(parents=True, exist_ok=True)
        Path(path).write_text(content)
        return f"Written to {path}"

    def run_command(self, cmd: str, cwd: str = ".") -> str:
        """Execute a shell command safely."""
        # Safety: block dangerous commands
        blocked = ["rm -rf /", "sudo", "DROP TABLE", "> /dev/sda"]
        if any(b in cmd for b in blocked):
            return f"BLOCKED: Dangerous command detected"

        result = subprocess.run(
            cmd, shell=True, cwd=cwd,
            capture_output=True, text=True, timeout=60
        )
        return result.stdout + result.stderr

    def run_tests(self, test_cmd: str = "pytest") -> str:
        """Run the test suite and return results."""
        return self.run_command(test_cmd)

    def lint(self, path: str = ".") -> str:
        """Run linter on the codebase."""
        return self.run_command(f"ruff check {path}")

    def git_diff(self) -> str:
        """Show what changed."""
        return self.run_command("git diff")

from langchain_community.vectorstores import Chroma
from langchain_text_splitters import RecursiveCharacterTextSplitter

class ProjectKnowledge:
    def __init__(self, project_path: str):
        self.project_path = project_path
        self.vectorstore = None

    def index_project(self):
        """Index all project documentation and code."""
        docs = []
        for ext in ["*.md", "*.py", "*.ts", "*.json"]:
            for file in Path(self.project_path).rglob(ext):
                # Skip node_modules, venv, etc.
                if any(skip in str(file) for skip in ["node_modules", "venv", ".git"]):
                    continue
                docs.append({
                    "content": file.read_text(),
                    "path": str(file),
                    "type": ext
                })

        splitter = RecursiveCharacterTextSplitter(
            chunk_size=2000, chunk_overlap=200
        )

        texts = []
        metadatas = []
        for doc in docs:
            chunks = splitter.split_text(doc["content"])
            texts.extend(chunks)
            metadatas.extend([{"source": doc["path"]} for _ in chunks])

        self.vectorstore = Chroma.from_texts(
            texts=texts, metadatas=metadatas
        )

    def search(self, query: str, k: int = 5) -> list:
        """Search the knowledge base for relevant context."""
        return self.vectorstore.similarity_search(query, k=k)

def agent_loop(task: str, project_path: str):
    """Main agent execution loop."""
    knowledge = ProjectKnowledge(project_path)
    tools = DevTools()
    router = ModelRouter()

    state = {
        "task": task,
        "context": "",
        "model_used": "",
        "code_output": "",
        "test_results": "",
        "iteration": 0,
        "messages": []
    }

    # Build context from knowledge base
    relevant_docs = knowledge.search(task)
    state["context"] = "\n\n".join([d.page_content for d in relevant_docs])

    while True:
        state["iteration"] += 1
        model = route_task(state)
        state["model_used"] = model

        # Generate code with the best model
        state["code_output"] = router.generate(
            model=model,
            prompt=f"Task: {task}\n\nContext:\n{state['context']}\n\nPrevious attempt: {state.get('code_output', '')}\n\nTest results: {state['test_results']}\n\nPlease provide improved code.",
            context=state["context"]
        )

        # Apply the changes
        # (In production, parse the model output to extract file changes)
        tools.write_file("output.py", state["code_output"])

        # Run tests
        state["test_results"] = tools.run_tests()

        print(f"Iteration {state['iteration']}: Used {model}")
        print(f"Tests: {state['test_results'][:200]}")

        # Check if we should continue
        next_step = should_iterate(state)
        if next_step == END:
            break

    return state["code_output"]

pip install langgraph langchain anthropic openai google-generativeai chromadb redis

git clone https://github.com/your-repo/coding-agent
cd coding-agent
cp .env.example .env
# Edit .env with your API keys

from agent import ProjectKnowledge, agent_loop

# Index your codebase
kb = ProjectKnowledge("/path/to/your/project")
kb.index_project()

# Try your first task
result = agent_loop("Fix the login bug in auth/views.py", "/path/to/your/project")
print(result)