Aider

Aider AI

Aider AI

Aider AI

Aider AI

Aider AI

Aider AI

Aider AI

Aider AI

Aider AI

Aider AI

The real bottleneck in multi-agent coding isn't the model — it's everything around it

I've been running multi-agent coding setups for months now (Codex, Claude Code, Aider — mixing and matching). Here's the uncomfortable truth nobody talks about in the demos: The models are not the bottleneck anymore. What breaks in practice: - Agent A and Agent B both edit utils.ts → conflict - No system of record for who owns which files - "Parallel" work means "clean it up later" - Merge step takes longer than the generation step The generation layer is solved. The coordination layer is where everything falls apart. So I built a CLI that handles the orchestration between agents: Isolated workspaces — each task gets its own Git worktree File claims — tasks declare ownership before execution, overlaps rejected upfront Contract enforcement — agents can't violate their file boundaries DAG-aware execution — tasks with dependencies run in the right order Works with everything — Codex, Claude Code, Aider, Cursor, or any CLI The key insight: you don't need another model or agent. You need a coordination layer between them. ```bash npm install -g @levi-tc/ruah Example: Codex handles API, Claude handles frontend ruah task create api --files "src/api/" --executor codex --prompt "Build REST API" ruah task create ui --files "src/components/" --executor claude-code --prompt "Build React UI" ``` Repo: https://github.com/levi-tc/ruah (MIT, zero dependencies) For people running multi-agent setups: is the coordination problem something you've solved differently, or are you just grinding through the merge cleanup manually? submitted by /u/ImKarmaT [link] [comments]

I built a tool that gives your AI project a "Drift Score" — how much has AI deviated from what you actually wanted

I've been building with Claude Code and Cursor for months. The biggest problem isn't bugs — it's drift. The AI slowly changes your architecture without you noticing. Your auth gets rewritten. Your API contracts shift. Your database schema mutates. So I built SpecLock — an open-source constraint engine that tracks this. Three numbers tell the whole story: **Drift Score (0-100)** — How much has AI deviated from your intent? $ speclock drift Drift Score: 23/100 (B) — minor drift Trend: worsening | Violations: 4 | Overrides: 1 **Lock Coverage** — What's unprotected in your codebase? $ speclock coverage Lock Coverage: 60% (B) [EXPOSED] CRITICAL: payments — 1 file at risk Suggested: speclock lock "Never modify payments without permission" **Lock Strengthener** — Are your constraints actually strong enough? $ speclock strengthen [WEAK] 30/100 "dont break things" → suggested improvement [STRONG] 90/100 "Never expose API keys in client-side code" It also syncs your constraints to every AI tool at once: $ speclock sync --all ✓ Cursor → .cursor/rules/speclock.mdc ✓ Claude Code → CLAUDE.md ✓ Copilot → .github/copilot-instructions.md ✓ Windsurf, Gemini, Aider, AGENTS.md One source of truth. 49 MCP tools. 929 tests. MIT licensed. GitHub: https://github.com/sgroy10/speclock Install: `npx speclock setup --goal "My project" --template safe-defaults` No other tool measures architectural drift in real time. SonarQube and CodeScene measure code quality after the fact. Only SpecLock knows what was *intended* vs what was *done*. Would love feedback — what constraints would you want to lock in your projects? submitted by /u/ServiceLiving4383 [link] [comments]

I built an orchestration layer for running multiple Claude Code sessions on the same repo without them destroying each other's work

I've been using Claude Code as my primary coding tool for months now. It's genuinely great for focused single-task work. But I kept hitting the same wall: **The moment I needed two Claude Code sessions working on the same repo, everything fell apart.** Session A rewrites a file. Session B is working from a stale read of that file. Session A finishes, I merge, then Session B finishes with a version of the file that conflicts. Now I'm spending 20 minutes hand-resolving merge conflicts that an agent was supposed to save me from. Or: I'm on a feature that touches auth, API routes, and frontend components. The context window can't hold all of it at once. So I split it into three sessions — but now I'm the scheduler. I'm the merge coordinator. I'm the conflict detector. I'm doing the work the agents were supposed to eliminate. **So I built ruah.** It's an open-source CLI that sits underneath Claude Code (or any coding agent) and handles the coordination layer: - **Worktree isolation** — each task gets its own git worktree and branch. Agents literally cannot see each other's uncommitted work. No stale reads, no interference. - **File locking** — before a task starts, ruah locks the file patterns it will touch. If two tasks overlap, you find out *before* any agent runs, not after 10 minutes of wasted compute. - **DAG workflows** — define a markdown file with tasks and dependencies. Independent tasks run in parallel, dependent tasks wait. ruah's planner analyzes file overlaps and decides per-stage whether to run full parallel, parallel with modification contracts, or serial. - **Subagent spawning** — a running Claude Code session can spawn child tasks. Children branch from the parent (not main), do their work in isolation, and merge back into the parent first. Parent merge to main is blocked until children are done. - **Governance gates** — if you have a `.claude/governance.md`, ruah auto-runs those gates before every merge. Real example of what my workflow looks like now: # tests waits automatically until auth and api finish The auth and api tasks run in parallel in separate worktrees with locked file scopes. The test task doesn't start until both are merged. No manual coordination. It also works with Aider, Codex, and any other CLI — 7 built-in executor adapters — but I built it primarily because Claude Code is what I use daily and the single-session ceiling was the bottleneck. **Try it:** npx /ruah demo 3-second interactive demo that creates a temp repo, shows isolation, locking, and conflict detection, then cleans up. Repo: https://github.com/levi-tc/ruah Zero runtime deps, MIT, TypeScript, 152 tests. --- Genuine question for other Claude Code power users: **what's your current strategy when a task is too big for one session?** Do you split manually across sessions? Use worktrees by hand? Just feed everything into one massive context and hope? I'm curious what the actual workflow looks like for people hitting this ceiling. ruah task create auth --files "src/auth/**" --executor claude-code \ --prompt "Implement JWT authentication with refresh tokens" ruah task create api --files "src/api/**" --executor claude-code \ --prompt "Build REST endpoints for user management" ruah task create tests --files "test/**" --executor claude-code \ --prompt "Write integration tests for auth and API" \ --depends auth,api ruah task start auth ruah task start api submitted by /u/ImKarmaT [link] [comments]

I built snip; cuts Claude Code token usage by 60-90% with YAML filters (open source, Go)

Inspired by rtk (Rust Token Killer), I built snip to solve the same problem with a different philosophy: filters should be data, not compiled code. AI coding agents burn tokens on verbose shell output. A passing go test is hundreds of lines the LLM never uses. git log dumps full metadata when a one-liner suffices. snip sits between Claude Code and the shell, filtering output through declarative YAML pipelines before it hits the context window. Before: go test ./... → 689 tokens After: 10 passed, 0 failed → 16 tokens (97.7% reduction) Setup is one command: brew install edouard-claude/tap/snip snip init That's it — every shell command Claude runs now goes through snip. Where snip differs from rtk: filters are YAML files you drop in a folder, not Rust code compiled into the binary. 16 composable pipeline actions (keep/remove lines, regex, JSON extract, state machine, group_by, dedup...). Write your own filter in 5 minutes without touching Go. The engine and filters evolve independently. Also works with Cursor, Copilot, Gemini CLI, Aider, Windsurf, Cline. GitHub: https://github.com/edouard-claude/snip Happy to answer questions! submitted by /u/edouard-claude [link] [comments]

What broke when you tried running multiple coding agents?

I'm researching AI coding agent orchestrators (Conductor, Intent, etc.) and thinking about building one. For people who actually run multiple coding agents (Claude Code, Cursor, Aider, etc.) in parallel: What are the biggest problems you're hitting today? Some things I'm curious about: • observability (seeing what agents are doing) • debugging agent failures • context passing between agents • cost/token explosions • human intervention during long runs • task planning / routing If you could add one feature to current orchestrators, what would it be? Also curious: How many agents are you realistically running at once? Would love to hear real workflows and pain points. submitted by /u/_karthikeyans_ [link] [comments]

I built a persistent memory framework for Claude Code after 1,500+ sessions. It’s open source now.

After months of daily use across 60+ projects, I got tired of re‑explaining my codebase every session. So I built a system that gives Claude (or any AI coding tool) a structured, persistent brain. The core problem: everyone’s solution is “make the instruction file bigger.” But a 2,000‑line CLAUDE.md eats your context window before you’ve asked a question, and your AI ends up ignoring half of it. SuperContext takes the opposite approach — small, targeted files loaded only when relevant: Constitution (~200 lines, always loaded) Global rules, routing, preferences Living Memory (~50 lines, always loaded) Behavioral gotchas that prevent repeated mistakes Project Brains (loaded on entry) Per‑project business rules, schemas, changelogs Knowledge Store (on demand) Searchable SQLite database for infrastructure, APIs, reference data Session Memory Automatic conversation logging so your AI recalls past decisions The repo includes two things: The full guide Theory, architecture, anti‑patterns, tool‑specific setup for Claude Code, Cursor, Copilot, Codex, Aider, etc. An executable prompt Hand it to your AI, say “run this,” and it discovers your projects, migrates existing content, and builds the whole system in ~10 minutes. No manual setup. It was developed building construction management integrations (Vista, Procore, Monday.com), where getting context wrong means real production problems. The AI went from “helpful but forgetful” to genuinely knowing our systems. GitHub: https://github.com/sms021/SuperContext Happy to answer questions about the architecture or how it works in practice. submitted by /u/sms021 [link] [comments]

I stopped building "another orchestrator" and started building Kubernetes for coding agents -- model policy, verification, 13 adapters, 5000 tests

I stopped building "another orchestrator" and started building Kubernetes for coding agents - model policy, verification, 13 adapters, 5000 tests Every week there's a new tool that spawns Claude Code in parallel worktrees. That's the hello world of this space. It's maybe 5% of the actual problem. I've been building Bernstein for a few months and went through that phase too. Here's what the other 95% looks like: Agents lie. Not maliciously, but they say "tests pass" when tests don't. They say "I committed" when they didn't. So Bernstein has a "janitor" that independently verifies every task - runs the tests itself, checks the diff, lints the output. Without this you're just merging vibes. Once you're running 5+ agents you start caring about model policy - which providers see your code, cost ceilings, data residency. Your CISO cares even if you don't. Think K8s network policies but for LLM providers. None of the worktree-spawners handle this. The orchestrator itself is pure Python - deterministic scheduling, zero LLM tokens on coordination. Most multi-agent frameworks use an LLM to schedule other LLMs which is slow, expensive, and non-deterministic. 13+ adapters (Claude Code, Codex, Gemini CLI, Cursor, Aider, Amp, Qwen, Roo Code, Goose, Kilo, Kiro, OpenCode, and a generic one). If your orchestrator only works with one agent, you're locked in and you'll feel it the moment rate limits hit. The K8s analogy is intentional. K8s didn't win because it ran containers - Docker ran containers. K8s won because it was the governance and lifecycle layer. That's what I'm building for coding agents. ~5000 tests, HMAC audit logs, circuit breakers, cost anomaly detection, PII scanning. Solo dev from Israel, project outgrew me. Contributors very welcome: https://github.com/chernistry/bernstein submitted by /u/alex_chernysh [link] [comments]

i use claude code alongside codex cli and cline. there was no way to see total cost or catch quality issues across all of them, so i updated both my tools

I've posted about these tools before separately. This is a combined update because the new features work together. Quick context: I build across 8 projects with multiple AI coding tools. Claude Code for most things, Codex CLI for background tasks, Cline when I want to swap models. The two problems I kept hitting: No unified view of what I'm spending across all of them No automated quality check that runs inside the agent itself CodeLedger updates (cost side): CodeLedger already tracked Claude Code spending. Now it reads session files from Codex CLI, Cline, and Gemini CLI too. One dashboard, all tools. Zero API keys needed, it reads the local session files directly. New features: Budget limits: set monthly, weekly, or daily caps per project or globally. CodeLedger alerts you at 75% before you blow past it. Spend anomaly detection: flags days where your spend spikes compared to your 30-day average. Caught a runaway agent last week that was rewriting the same file in a loop. OpenAI and Google model pricing: o3-mini, o4-mini, gpt-4o, gpt-4.1, gemini-2.5-pro, gemini-2.5-flash all priced alongside Anthropic models now. For context on why this matters: Pragmatic Engineer's 2026 survey found 70% of developers use 2-4 AI coding tools simultaneously. Average spend is $100-200/dev/month on the low end. One dev was tracked at $5,600 in a single month. Without tracking, you're flying blind. vibecop updates (quality side): The big one: vibecop init. One command sets up hooks for Claude Code, Cursor, Codex CLI, Aider, Copilot, Windsurf, and Cline. After that, vibecop auto-runs every time the AI writes code. No manual scanning. It also ships --format agent which compresses findings to ~30 tokens each, so the agent gets feedback without eating your context window. New detectors (LLM-specific): exec() with dynamic arguments: shell injection risk. AI agents love writing exec(userInput). new OpenAI() without a timeout: the agent forgets, your server hangs forever. Unpinned model strings like "gpt-4o": the AI writes the model it was trained on, not necessarily the one you should pin. Hallucinated package detection: flags npm dependencies not in the top 5K packages. AI agents invent package names that don't exist. Missing system messages / unset temperature in LLM API calls. Finding deduplication also landed: if the same line triggers two detectors, only the most specific finding shows up. Less noise. How they work together: CodeLedger tells you "you spent $47 today, 60% on Opus, mostly in the auth-service project." vibecop tells you "the auth-service has 12 god functions, 3 empty catch blocks, and an exec() with a dynamic argument." One tracks cost, the other tracks quality. Both run locally, both are free. npm install -g codeledger npm install -g vibecop vibecop init GitHub: https://github.com/bhvbhushan/codeledger https://github.com/bhvbhushan/vibecop Both MIT licensed. For those of you using Claude Code with other tools: how are you keeping track of total spend? And are you reviewing the structural quality of what the agents produce, or just checking that it compiles? submitted by /u/Awkward_Ad_9605 [link] [comments]

anyone else running Claude Code alongside other agents? found a way to get them collaborating in the same thread

so my main agent is claude code and i love it but i also keep codex cli around for when i want a second opinion, and sometimes aider for specific refactoring tasks. the annoying part has been that they all live in separate terminals with zero awareness of each other the workflow i had before was basically: ask claude code to implement something, copy the relevant output, paste it into codex for review, then manually reconcile their suggestions. lots of tab switching and clipboard gymnastics recently started using openagents workspace which lets you put multiple agents in the same thread. you run one command and it auto detects whatever agents you have installed. so now i have claude code and codex in the same conversation and they actually read each others messages my favorite thing so far: i had claude code write an api endpoint, then in the same thread asked codex to review it. codex could see exactly what claude wrote and gave specific feedback referencing the actual code. no copy pasting involved. claude then responded to the feedback and fixed the issues. felt like having two devs pair programming theres also shared files between agents which is nice. claude writes something, codex can read it directly being honest about the rough edges though. when you have 3+ agents in one thread they sometimes talk over each other or respond when you didnt ask them to. the ui is pretty barebones, no way to organize or label your agents so you end up clicking around. and the desktop app is still new and a bit buggy, i stick to the cli version but for anyone who uses claude code as their primary agent and occasionally pulls in others, its been a legit improvement over my old copy paste workflow. the whole thing is open source (apache 2.0) if anyone wants to check it out: https://github.com/openagents-org/openagents curious what other claude code users are doing when they need a second agent's perspective on something submitted by /u/VenomPulse69 [link] [comments]

I made an SSH Terminal for my Claude Code sessions

I was taking a shit a few months ago and got really frustrated that I couldn't access my Claude Code sessions. I also hated not being able to check my sessions when I was out grocery shopping at CostCo or was waiting for my wife to get out of the bathroom on dates. So I made an app. It started as a simple SSH terminal like any other you can download on the Play Store. I started making it more complex and just kept adding features: session persistence, port forwarding and an in-app browser to check your front end on remote servers, AI change tracking, SFTP file directory browser with built-in Code Editor, file previews, Natural Language to Command, AI chatbot, settings based front page animation, audit logging, encrypted vault, the list goes on. My friend had the same problem and wished he could code easily in his hot tub. Therefore, we joined up to make this app as slick as possible. We released it on the Google Play store (currently pending on IOS store) as TerminaLLM. It's currently free to download. It has subscription tiers but I think the free tier is pretty useful. Here's the full breakdown: Free Tier: Terminal & Sessions Full SSH terminal with session persistence (survive disconnects) Requires our fork of a C-library called dtach to be installed on the remote machine (instructions included in-app) 5 saved connection profiles with live health check dots, environment variables, and startup commands Push notifications for stale sessions (could indicate your AI needs your input!) SFTP File Management Browse, upload, download, rename, delete, mkdir on remote servers File preview with syntax highlighting Recursive file search Voice Input Platform speech-to-text On-device Whisper AI transcription compatibility AI Coding Workflow Auto-detects Claude Code, Aider, Cursor, Copilot and their states Auto-detects OAuth/auth URLs from AI tools Media drop — camera/gallery/files → SFTP upload → path into terminal Productivity 50+ command palette with search and favorites Reusable snippets with variable interpolation Visual ANSI prompt color customizer Auto-run commands on connect Themes & Customization All 15 built-in themes Custom theme editor Import iTerm2 and JSON themes Landscape split QWERTY keyboard Security (all free, always) TOTP MFA + Face ID / Touch ID / Fingerprint AES-256-GCM encrypted credential vault with auto-fill Paranoid / Casual / Speedster security presets (speedster is my personal favorite) Security event audit log with JSON export Screenshot/screen recording prevention Platform-Specific (Pending Apple Approval) iOS Live Activities — Lock Screen + Dynamic Island SSH status Plus — AI change detection, SFTP code editor, batch ops, bookmarks, session sharing (creates .cast files), port forwarding, jump host/bastion server, encrypted backup, session recording, unlimited profiles Pro — AI chatbot + natural language to shell command translation For Claude Code specifically, we recommend generating an OAuth token using claude setup-token and setting that in your per-profile environment variables (CLAUDE_CODE_OAUTH_TOKEN) The /login command will be required consistently when using an SSH terminal. When going in headless, /login will be required on your first go which will open a browser tab prompting login on the server machine itself, which is why we recommend the OAuth token approach, especially if you're going to be far away from your machine. I personally use an always-on, wifi-capable raspberry-pi to wake my machine remotely since I don't like keeping my laptop off sleep all day every day. Please feel free to reach out with any questions! There's also the app website here: https://terminallm.app/ submitted by /u/ballesmen [link] [comments]

I built Scalpel — it scans your codebase across 12 dimensions, then assembles a custom AI surgical team. Open source, MIT.

I built the entire Scalpel v2.0 in a single Claude Code session using agent teams with worktree isolation. Claude Code spawned parallel subagents — one built the 850-line bash scanner, another built the test suite with 36 assertions across 3 fixture projects, others built the 6 agent adapters simultaneously. The anti-regression system, the verification protocol, the scoring algorithm — all designed and implemented by Claude Code agents working in parallel git worktrees. Claude Code wasn't just used to write code — it architected the system, reviewed its own work, caught quality regressions, and ran the full test suite before shipping. The whole v2 (scanner + agent brain + 6 adapters + GitHub Action + config schema + tests + docs) was built and pushed in one session. Scalpel is also **built specifically for Claude Code** — it's a Claude Code agent that lives in `.claude/agents/` and activates when you say "Hi Scalpel." It also works with 6 other AI agents. The Problem: AI agents are powerful but context-blind. They don't know your architecture, your tech debt, your git history, or your conventions. So they guess. Guessing at scale = bugs at scale. What Scalpel does: Scans 12 dimensions — stack, architecture, git forensics, database, auth, infrastructure, tests, security, integrations, code quality, performance, documentation Produces a Codebase Vitals report with a health score out of 100 Assembles a custom surgical team where each AI agent owns specific files and gets scored on quality Runs in parallel with worktree isolation — no merge conflicts The standalone scanner runs in pure bash — zero AI, zero tokens, zero subscription: ### ./scanner.sh # Health score in 30 seconds ### ./scanner.sh --json # Pipe into CI I scanned some popular repos for fun: Cal.com (35K stars): 62/100 — 467 TODOs, 9 security issues shadcn/ui (82K stars): 65/100 — 1,216 'use client' directives Excalidraw (93K stars): 77/100 — 95 TODOs, 2 security issues create-t3-app (26K stars): 70/100 — zero test files (CRITICAL) Hono (22K stars): 76/100 — 9 security issues Works with Claude Code, Codex, Gemini, Cursor, Windsurf, Aider, and OpenCode. Auto-detects your agent on install. Also ships as a GitHub Action — block unhealthy PRs from merging: - uses: anupmaster/scalpel@v2 with: ### fail-below: 60 ### comment: true GitHub: Click Here to visit Scalpel Free to use. MIT licensed. No paid tiers. Clone and run. Feedback welcome. submitted by /u/anupkaranjkar08 [link] [comments]

I built an open-source context framework for Codex CLI (and 8 other AI agents)

Codex is incredible for bulk edits and parallel code generation. But every session starts from zero — no memory of your project architecture, your coding conventions, your decisions from yesterday. What if Codex had persistent context? And what if it could automatically delegate research to Gemini and strategy to Claude when the task called for it? I built Contextium — an open-source framework that gives AI agents persistent, structured context that compounds across sessions. I'm releasing it today. What it does for Codex specifically Codex reads an AGENTS.md file. Contextium turns that file into a context router — a dynamic dispatch table that lazy-loads only the knowledge relevant to what you're working on. Instead of a static prompt, your Codex sessions get: Your project's architecture decisions and past context Integration docs for the APIs you're calling Behavioral rules that are actually enforced (coding standards, commit conventions, deploy procedures) Knowledge about your specific stack, organized and searchable The context router means your repo can grow to hundreds of files without bloating the context window. Codex loads only what it needs per session. Multi-agent delegation is the real unlock This is where it gets interesting. Contextium includes a delegation architecture: Codex for bulk edits and parallel code generation (fast, cheap) Claude for strategy, architecture, and complex reasoning (precise, expensive) Gemini for research, web lookups, and task management (web-connected, cheap) The system routes work to the right model automatically based on the task. You get more leverage and spend less. One framework, multiple agents, each doing what they're best at. What's inside Context router with lazy loading — triggers load relevant files on demand 27 integration connectors — Google Workspace, Todoist, QuickBooks, Home Assistant, and more 6 app patterns — briefings, health tracking, infrastructure remediation, data sync, goals, shared utilities Project lifecycle management — track work across sessions with decisions logged and searchable via git Behavioral rules — not just documented, actually enforced through the instruction file Works with 9 AI agents: Claude Code, Gemini CLI, Codex, Cursor, Windsurf, Cline, Aider, Continue, GitHub Copilot. Battle-tested I've used this framework daily for months: 100+ completed projects, 600+ journal entries, 35 app protocols running in production. The patterns shipped in the template are the ones that survived sustained real-world use. Plain markdown. Git-versioned. No vendor lock-in. Apache 2.0. Get started bash curl -sSL contextium.ai/install | bash Interactive installer with a gum terminal UI — picks your agent, selects your integrations, optionally creates a GitHub repo, then launches your agent ready to go. GitHub: https://github.com/Ashkaan/contextium Website: https://contextium.ai Happy to answer questions about the Codex integration or the delegation architecture. submitted by /u/Ashkaan4 [link] [comments]

[AI Agent] Master Tracking: Complete AI Agent Implementation

## 🎯 Goal Track the complete implementation of autonomous Python AI Agent for CoffeeOrderSystem. --- ## 📋 Implementation Steps ### Phase 1: Infrastructure (Week 1) - [ ] **Step 1:** Setup Python AI Agent Service infrastructure #133 - Python service with FastAPI - Docker integration - Basic health checks - Makefile commands ### Phase 2: AI Integration (Week 1-2) - [ ] **Step 2:** Implement Cognee integration with semantic code search #134 - CogneeService with RAG search - Architecture context gathering - Entity file discovery - Integration tests - [ ] **Step 3:** Implement PlannerAgent with LangChain #135 - TaskPlan models - LangChain planning chain - Prompt templates - Plan generation and posting ### Phase 3: Code Generation (Week 2-3) - [ ] **Step 4:** Implement DevAgent for code generation #136 - GitHub file operations - Code generation prompts - Create/modify/delete operations - Branch management - [ ] **Step 5:** Implement PRAgent and workflow orchestration #137 - PR creation with rich descriptions - Workflow orchestrator - Background task processing - Complete end-to-end flow ### Phase 4: Advanced Features (Week 3-4) - [ ] **Step 6:** Add learning/memory system - Store successful patterns in Cognee - Learn from PR reviews - Avoid failed patterns - Improve over time - [ ] **Step 7:** Add GitHub webhook listener - Auto-trigger on issue label - Real-time processing - Queue management - Concurrent task handling --- ## 🎯 Success Criteria ### MVP (Minimum Viable Product) - ✅ Agent creates plans for issues - ✅ Agent generates compilable code - ✅ Agent creates PRs with descriptions - ✅ Works for simple tasks (add field, update config) - ✅ Error handling with GitHub notifications ### Production Ready - ☐ Handles complex multi-layer changes - ☐ Learns from successful PRs - ☐ Automatic triggering via webhooks - ☐ Rate limiting and queue management - ☐ Comprehensive test coverage (>80%) - ☐ Monitoring and metrics --- ## 📊 Architecture Overview ``` ┌────────────────────────────────────┐ │ GitHub Issues (labeled: ai-agent) │ └───────────────┬────────────────────┘ │ ↓ (webhook or manual trigger) ┌───────────────┼────────────────────┐ │ WorkflowOrchestrator │ └───────────────┬────────────────────┘ │ ┌────────┼────────┐ │ │ │ ↓ ↓ ↓ PlannerAgent DevAgent PRAgent │ │ │ │ │ │ ┌───┼───┐ │ ┌───┼───┐ │ │ │ │ │ │ │ ↓ ↓ ↓ ↓ ↓ ↓ ↓ Cognee LLM GitHub GitHub (RAG) (GPT-4) (API) ``` ### Component Responsibilities **PlannerAgent:** - Analyzes GitHub issue - Searches codebase via Cognee - Creates structured TaskPlan - Posts plan as issue comment **DevAgent:** - Generates code via LLM - Creates/modifies/deletes files - Commits to feature branch - Preserves code style **PRAgent:** - Creates pull request - Writes comprehensive PR description - Links to original issue - Adds testing checklist **WorkflowOrchestrator:** - Coordinates all agents - Handles errors - Posts progress updates - Manages background execution --- ## 📦 Tech Stack ### Core - **Python 3.11+** - Agent runtime - **FastAPI** - Web framework - **LangChain** - LLM orchestration - **OpenAI GPT-4** - Code generation - **PyGithub** - GitHub API client ### AI/ML - **Cognee** - RAG and semantic search - **OpenAI Embeddings** - Vector search - **LangChain Chains** - Prompt management ### Infrastructure - **Docker** - Containerization - **PostgreSQL** - Shared with .NET API - **uvicorn** - ASGI server --- ## 📝 Usage Example ### 1. Create Issue ```markdown Title: Add loyalty points to Customer Labels: ai-agent, enhancement Description: Add LoyaltyPoints field (int, default 0) to Customer entity. Requirements: - Update Domain/Entities/Customer.cs - Update Application/DTOs/CustomerDto.cs - Create EF Core migration - Add unit tests ``` ### 2. Trigger Agent ```bash make agent-process # Enter issue number: 138 ``` ### 3. Monitor Progress Issue comments show: ``` 🤖 AI Agent Started Phase 1/3: Analyzing task... 🤖 Execution Plan Summary: Add LoyaltyPoints field to Customer entity Steps: 1. MODIFY Domain/Entities/Customer.cs 2. MODIFY Application/DTOs/CustomerDto.cs 3. CREATE Migration file 4. CREATE Test file 🛠️ Phase 2/3: Generating code (4 files)... ✅ Step 1/4: modify Customer.cs ✅ Step 2/4: modify CustomerDto.cs ... 📦 Phase 3/3: Creating pull request... 🤖 Pull Request Created: #139 Branch: ai-agent/issue-138 Ready for review! ``` ### 4. Review PR PR includes: - Closes #138 - Comprehensive description - File changes summary - Testing checklist - Risk assessment ### 5. Merge Agent learns from successful merge for future tasks. --- ## 🧪 Testing Strategy ### Unit Tests - Agent logic (plan parsing, code generation) - Service mocks (GitHub, Cognee) - P

Open-source coding agents like OpenCode, Cline, and Aider are solving a huge headache for developers

AI coding agents are proliferating, but the economics of running large language models (LLMs) are breaking down as developers juggle The post Open-source coding agents like OpenCode, Cline, and Aider are solving a huge headache for developers appeared first on The New Stack.