___ __ ________ ____ ________ __ __
/ | / / / / __ \/ __ \/_ __/ / / /
/ /| |/ / / / /_/ / / / / / / / /_/ /
/ ___ / /_/ / _, _/ /_/ / / / / __ /
/_/ |_\____/_/ |_|\____/ /_/ /_/ /_/
An autonomous, multi-agent engine built in Rust that resolves GitHub issues end-to-end — plan, code, test in sandboxes, and open pull requests with zero human intervention.
Auroth is an production-grade, autonomous software engineering agent system. Unlike generic Python agent frameworks built on heavy abstractions like LangChain or LangGraph, Auroth features a custom, low-latency Rust orchestration engine powered by Tokio and Axum.
When a GitHub issue is labeled with auroth-fix or dispatched via API, Auroth automatically clones the target repository, synthesizes file modification plans across multi-provider LLMs (Groq Llama 3.3, Google Gemini 2.0, Ollama, Anthropic), executes isolated unit test suites inside remote E2B sandboxes or Docker containers, iterates through a bounded 3-attempt review loop, and opens a production-ready GitHub Pull Request.
- Live Control Deck Dashboard: https://auroth.vercel.app
- Source Code Repository: https://github.com/adarshthakur9240/auroth
Auroth separates high-concurrency event ingestion and state machine orchestration (Rust) from the real-time monitoring interface (Next.js 16).
graph TD
subgraph GitHub ["GitHub Infrastructure"]
GH_Issue["GitHub Issue (labeled 'auroth-fix')"]
GH_PR["GitHub Pull Request"]
end
subgraph Backend ["Backend Engine (Render / Rust 1.85)"]
Axum["Axum Webhook Gateway & REST API"]
StateMachine["Agent State Machine Orchestrator"]
LLMRouter["Multi-LLM Provider Router"]
end
subgraph DataStore ["Data & Queue Layer"]
Postgres["Supabase PostgreSQL (State Machine Audit)"]
Redis["Upstash Redis (State Cache & Queue)"]
end
subgraph ExecEnv ["Isolated Execution Sandbox"]
E2B["E2B Remote Sandbox / Docker"]
end
subgraph LLMs ["LLM Provider Failover"]
Groq["Groq (Llama-3.3-70b)"]
Gemini["Google Gemini 2.0 Flash"]
Ollama["Ollama (Local Llama 3.1)"]
Anthropic["Anthropic Claude 3.5 Sonnet"]
end
subgraph Frontend ["Frontend Dashboard (Vercel / Next.js 16)"]
ControlRoom["Industrial Control Deck UI"]
end
GH_Issue -->|"Webhook Event (HMAC-SHA256)"| Axum
Axum --> StateMachine
StateMachine <-->|"Persist State & History"| Postgres
StateMachine <-->|"Queue & Cache"| Redis
StateMachine --> LLMRouter
LLMRouter --> Groq
LLMRouter --> Gemini
LLMRouter --> Ollama
LLMRouter --> Anthropic
StateMachine -->|"Upload Code & Run Tests"| E2B
E2B -->|"Return Exit Code, Stdout, Stderr"| StateMachine
StateMachine -->|"Push Branch & Create PR"| GH_PR
ControlRoom <-->|"Poll /jobs API (3s)"| Axum
sequenceDiagram
autonumber
actor User as GitHub / User
participant Axum as Axum Webhook Gateway
participant Engine as State Machine Orchestrator
participant LLM as LLM Provider Router
participant Sandbox as E2B Remote Sandbox
participant GH as GitHub API / Octocrab
User->>Axum: POST /webhooks/github or POST /jobs
Axum->>Engine: Spawn Job Execution Async Task
Engine->>Engine: Stage 01: Ingest & Clone Workspace
Engine->>LLM: Stage 02: Synthesize File Plan & Approach
LLM-->>Engine: JSON Plan (files_to_change, approach)
Engine->>LLM: Stage 03: Synthesize Code Modifications
LLM-->>Engine: Unified Code Diff / File Content
loop Execution & Verification (Max 3 Retries)
Engine->>Sandbox: Stage 04: Upload Workspace & Run Tests
Sandbox-->>Engine: Stdout, Stderr, Exit Code
alt Tests Passed (Exit Code 0)
Engine->>LLM: Review Code Changes & Test Logs
LLM-->>Engine: Review Approval
else Tests Failed (Exit Code != 0)
Engine->>LLM: Feed Error Trace & Request Fix
LLM-->>Engine: Updated Code Modifications
end
end
Engine->>GH: Stage 05: Push Branch & Create Pull Request
GH-->>User: Pull Request Opened (Closes #Issue)
Auroth guarantees deterministic state transitions with no infinite loops or stuck workers.
stateDiagram-v2
[*] --> Planning : Job Enqueued
Planning --> Coding : Plan Synthesized
Coding --> Testing : Code Applied
Testing --> Reviewing : Test Execution Finished
Reviewing --> Coding : Rejection / Test Failure (Retry Count < 3)
Reviewing --> Succeeded : Approved & PR Created
Reviewing --> Failed : Retry Limit Exceeded (3/3)
Planning --> Failed : Exception / API Error
Coding --> Failed : LLM / Git Error
Persisted in Supabase PostgreSQL with PgBouncer Transaction Pooler compatibility (statement_cache_capacity(0)).
erDiagram
JOBS {
uuid job_id PK
string repo_url
bigint issue_number
string issue_title
string issue_body
string current_state
integer retry_count
jsonb history
timestamp created_at
timestamp updated_at
}
| Technology | Role | Technical Justification |
|---|---|---|
| Rust 1.85 | Core Orchestrator Engine | Zero-cost abstractions, memory safety, and thread-safe async concurrency. |
| Axum & Tokio | Web Gateway & Async Runtime | High-throughput asynchronous HTTP routing and background job worker pool. |
| PostgreSQL (Supabase) | Audit & State Persistence | Relational store for step execution traces with PgBouncer compatibility. |
| Redis (Upstash) | Cache & Queue | Low-latency state caching and concurrency control. |
| E2B Sandbox | Ephemeral Remote Execution | Secure, isolated micro-VM sandboxes for running untrusted test code with 120s limits. |
| Groq / Gemini / Ollama | Multi-Provider LLM Router | Failover model routing supporting ultra-fast Llama 3.3, Gemini 2.0 Flash, and local LLMs. |
| Next.js 16 (App Router) | Industrial Control Deck | Server-rendered frontend featuring dynamic route management and React Query polling. |
| Three.js & R3F | 3D Hero Core Visualization | Interactive 3D metallic agent core rendering with mouse parallax distortion. |
| GSAP & Framer Motion | UI Micro-Interactions | Neo-brutalist entrance stamp animations and tabular count-up counters. |
| Docker | Fallback Sandbox Execution | Local container fallback runner when E2B API keys are unconfigured. |
GitHub issue events labeled auroth-fix are received via HMAC-SHA256 signed webhooks. Auroth verifies the payload signature, clones the repository into an isolated temporary workspace, and configures local git author credentials (user.name "Auroth Agent").
The orchestrator generates a summary of the repository file structure and queries the LLM provider for a structured JSON execution plan:
{
"files_to_change": ["src/math.rs"],
"approach": "Add zero-check guard to safe_divide before division operation",
"risk_notes": "Ensure return value matches expected zero fallback"
}For each target file, Auroth fetches the current contents, feeds the issue spec and strategy to the LLM router, receives synthesized code modifications, and applies changes directly to the local workspace.
Auroth creates a fresh remote E2B sandbox (or local Docker container), uploads the modified workspace, detects the project test runner (cargo test, npm test, pytest), and executes tests with a strict 120-second timeout.
Upon test pass approval, Auroth configures remote git credentials using a GitHub App Installation Access Token (https://x-access-token:<TOKEN>@github.com/...), pushes branch auroth/fix-issue-<number>, and opens a GitHub Pull Request referencing Closes #<number>.
- Rust 1.85+ (
rustup update stable) - Node.js 18+ &
npm - Docker (Optional, for local sandbox fallback)
- Groq or Gemini API Key (Free tier available)
git clone https://github.com/adarshthakur9240/auroth.git
cd aurothCopy .env.example to .env inside orchestrator/ and .env.local inside dashboard/:
| Variable | Description | Default / Source | Required |
|---|---|---|---|
PORT |
Axum server port | 3000 (Render dynamically overrides) |
Yes |
DATABASE_URL |
Supabase Postgres Connection String | postgresql://...:6543/postgres |
Yes |
MIGRATION_DATABASE_URL |
Direct Postgres Connection String (Port 5432) | postgresql://...:5432/postgres |
No |
REDIS_URL |
Upstash Redis Connection String | rediss://... |
Yes |
LLM_PROVIDER |
Active LLM backend provider | "groq", "gemini", "ollama", "anthropic" |
Yes |
GROQ_API_KEY |
Groq API Key | Console Groq | Conditional |
E2B_API_KEY |
E2B Sandbox API Key | E2B Console | No (Docker fallback) |
GITHUB_APP_ID |
GitHub App ID for PR creation | GitHub Developer Settings | No |
GITHUB_APP_PRIVATE_KEY_PATH |
Path to RSA PEM Private Key | ./github-app.pem |
No |
Terminal 1 — Rust Orchestrator Backend:
cd orchestrator
cargo run --bin orchestratorTerminal 2 — Next.js Control Deck Dashboard:
cd dashboard
npm run devOpen http://localhost:3000 to view the Industrial Control Deck.
Automated benchmark evaluation metrics measured via cargo run --bin bench_runner:
| Metric | Measured Value |
|---|---|
| Total Issues Attempted | 5 |
| Resolve Rate (% Succeeded) | 0.0% |
| Avg Issue-to-PR Latency (Successes) | 0.00s |
| Avg Retries per Successful Job | 0.00 |
Source-of-truth automated evaluation metrics measured by
bench_runnerbinary against SWE-bench-lite task specifications.
- Isolated Remote Sandboxing: Tests run in ephemeral E2B / Docker containers with 120s limits, preventing host system contamination.
- Bounded 3-Attempt Review Loop: Max 3 retries on code review rejection before graceful fallback to
Failed. - Scoped GitHub App Tokens: Authenticates using short-lived installation access tokens scoped strictly to target repos.
- Sensitive Credential Sanitization: All access tokens (
x-access-token:***@) are masked in logs and dashboard traces. - Temporary Workspace Cleanup: Workspace directories are automatically destroyed upon process completion.
auroth/
├── orchestrator/ # Rust 1.85 Backend Orchestrator Crate
│ ├── src/
│ │ ├── main.rs # Axum HTTP Server & Application Entrypoint
│ │ ├── state_machine.rs # Core Agent State Machine Loop (Plan/Code/Test/Review)
│ │ ├── llm.rs # Multi-LLM Provider Router (Groq/Gemini/Ollama/Anthropic)
│ │ ├── e2b_client.rs # E2B Sandbox REST API Integration & Guard
│ │ ├── docker_runner.rs # Local Docker Fallback Container Test Runner
│ │ ├── github.rs # Workspace Cloner & Git CLI Interface
│ │ ├── github_app.rs # GitHub App JWT & Authenticated PR Creator
│ │ ├── db.rs # Supabase PostgreSQL & MemoryStore Operations
│ │ └── bin/
│ │ └── bench_runner.rs # SWE-Bench Automated Evaluation Runner
│ ├── migrations/ # PostgreSQL DDL SQL Migrations
│ └── Dockerfile # Production Multi-Stage Dockerfile for Render
├── dashboard/ # Next.js 16 Industrial Control Deck Frontend
│ ├── app/
│ │ ├── page.tsx # Landing Page with 3D Core & GSAP Pipeline
│ │ ├── dashboard/page.tsx # Control Deck Jobs Table & LLM Status Strip
│ │ ├── jobs/[id]/page.tsx # Stamped Job Execution Trace & Diff Viewer
│ │ └── components/ # 3D Canvas, Status Badges, Diff Viewer, Custom Icons
├── .github/workflows/
│ └── deploy.yml # GitHub Actions CI Verification Workflow
├── .env.example # Comprehensive Environment Variables Template
└── README.md # Project Documentation
- Multi-Repository Workspaces: Support cross-repository dependencies and mono-repo sub-packages.
- Real-Time WebSocket Traces: Replace 3s HTTP polling with bidirectional Axum WebSockets.
- Local vLLM / Ollama Cluster Support: High-throughput self-hosted open model execution.
- Automated Benchmark Continuous Integration: Run
bench_runnerautomatically on push to track resolve rates.
Built by Adarsh's Team
- GitHub: https://github.com/adarshthakur9240
- LinkedIn: https://www.linkedin.com/in/adarsh-singh-7683612a4/
Distributed under the MIT License. See LICENSE for more details.