Autonomous AI Agency

Paste your website URL. Get a CTO-grade audit in minutes. Then let the agency that produced it go to work — on your infrastructure.

Self-hosted · MIT · Your servers, your models, your data

Try it live — free sandbox, resets every 24h · See the proof · Need assistance?

• Don't trust it — check the proof
• What it is
• Who this is for
• Start with the audit
• Then the agency takes over
• How the agents keep themselves honest
• Honest model economics
• Setup (self-hosted)
• Screens
• Architecture, security, license
• Contributing

Don't trust it — check the proof

Most "autonomous agent" projects show you a demo video. Here are artifacts instead:

What it is

Autonomous AI Agency is a self-hosted platform that turns one website URL into a working AI operations team. It scans your site's tech stack, provisions the specialist agents your business actually needs (from 35 families), and runs them 24x7 on hardware you control — with human approval gates on anything that ships. Under the hood: an OpenAI-compatible proxy, multi-provider model routing with automatic failover, a three-role plan → execute → verify agent loop, and full observability. MIT licensed.

This page is the short version — the full tour (every screen, schedule, runtime, and config variable) lives in docs/platform-guide.md.

Who this is for

• You're paying per-seat for an AI dev/ops tool and want the same leverage on infrastructure you control, with no usage metering and no vendor lock-in.
• You need AI agents that write to production systems but every tool you've tried either has no approval gates (too risky) or requires a human in the loop for everything (too slow). The three-tier trust model below is built for exactly this middle ground.
• You're evaluating "autonomous coding agent" platforms and want to see one running on its own codebase in public, with its own PR history as evidence, rather than a demo video.
• You care where your data goes. Self-hosted means your code, your customer data, and your prompts never transit a third-party inference relay.

If none of those describe you, this is probably more platform than you need — a single-repo coding assistant (Claude Code, Cursor, Aider) is a better fit for "just help me write code."

Start with the audit — no signup, no repo access, no trust required

The entry point is deliberately the lowest-risk thing an agency can do: read-only analysis.

• 102 deterministic checks across six pillars: Technical SEO, Content, Security headers, Social, GEO (generative-engine optimization: llms.txt, AI-crawler access, citable anchors) and AIO (answer-engine optimization: JSON-LD structured data, E-E-A-T markup)
• 0–100 health score, overall and per pillar
• Revenue-at-risk quantification — pass your monthly organic revenue and every finding is priced (a clearly-labeled model estimate, never a fabricated loss)
• Screaming Frog-compatible CSV exports — drops into existing SEO workflows
• Repo-aware auto-fix — connect a repo later and the agent proposes dry-run diffs for fixable findings (apply=true writes them)
• An agent-ready delegation plan — every finding comes back as a WSJF-prioritized work package assigned to a specialist. That's the handoff from "audit" to "agency."

# Self-hosted, from a clone:
pip install -r requirements.txt
PYTHONPATH=. python scripts/run_seo_audit.py --website-url https://yourcompany.com --output-dir ./my-audit

Engine docs: docs/seo-audit.md · Example output: proof/audits/

Then the agency takes over — at your pace

Trust is granted in steps, never all at once:

1. Read-only — audits, uptime/TLS monitoring, stack-drift detection, CVE scans. Zero write access.
2. Dry-run — agents propose diffs, draft PRs, draft replies. You read everything before it exists anywhere real.
3. Gated writes — agents open PRs, update docs, triage tickets. Nothing merges, deploys, or messages externally without your explicit approval. High-stakes actions always pause; you choose which low-risk classes of work to auto-approve.

After onboarding, the standing schedules run themselves: website health every 30 minutes, security audit daily, stack-change detection daily, code-quality scan daily, trend watch every 6 hours, docs sync on every push. You talk to a CEO agent in plain English ("fix the memory leak in issue #142"); it decomposes the job, delegates to the right specialist, and returns results with evidence — PR link, test output, reasoning trace.

Full roster, screens, loop engineering, and configuration: docs/platform-guide.md.

How the agents keep themselves honest

Consistent with the "check the proof" ethos above, none of this is described only in prose — every line links to the module or test file that implements it:

Full gap analysis and every new configuration variable: docs/AGENT_AUTONOMY_ROADMAP.md.

What's New (2026-07-24)

Structured output strict mode + refusal handling. The OpenAI json_schema + strict: true pattern is now the preferred way to request schema-conformant JSON from any model (replacing the legacy json_object mode). The proxy translates strict-mode requests into a tighter system-prompt constraint for Anthropic and other providers that don't natively support it, and detects model refusals (choices[0].message.refusal) so callers get a clear error instead of empty/garbled JSON.

MCP tools/list TTL caching. The agent's MCP client now respects the ttlMs field from tools/list responses (per the MCP spec 2026-07-28 RC), eliminating redundant round-trips to stable tool registries. Configurable default: 60 s.

New model catalog entries. The cost-attribution table now includes the July 2026 model releases: GPT-5.6 Sol/Terra/Luna (OpenAI's o3 successors, GA July 9), Claude Sonnet 5 (1M context, adaptive thinking), and o3 (with deprecation flag for late August). Provider cost breakdowns on the Observability screen update automatically.

Honest model economics

• The free 24h sandbox runs on free-tier models (Cerebras, Groq, NVIDIA NIM) with automatic failover. It demonstrates the orchestration loop end to end; it is not the output quality you'd run a company on.
• Production runs on your infrastructure with your keys. Anthropic Claude, OpenAI-compatible endpoints, AWS Bedrock, NVIDIA NIM, Groq, Cerebras, DeepSeek, and local Ollama are all supported by the same router — point the brain at a top-tier model from the Providers screen and every specialist upgrades instantly, no redeploy.
• No data leaves your server. No cloud relay, no usage telemetry, no shared inference endpoint, no per-seat pricing.

Need assistance?

The software is free and always will be (MIT). If you'd like a hand putting it to work — or advice on AI adoption in general — I'm happy to assist.

I built this platform end-to-end: multi-provider LLM routing with failover, multi-agent orchestration, human-approval workflows, observability, and a CI pipeline where the agents themselves ship the code (proof). I consult on AI strategy and agentic automation, and I can assist with deploying this platform on your own infrastructure with top-tier models (Claude, GPT — all supported), onboarding your company, and tuning the specialist fleet to your stack. A hands-on 2-week pilot is the usual starting point; early design partners get generous terms in exchange for a public case study.

• 📧 [email protected] — tell me your URL and what you'd like automated first
• 📋 Request a pilot / ask a question — public form, answered within 48 hours
• Or simply run the audit on your own site and send me the report — I'll walk you through what the fleet would do about it, free.

Setup (self-hosted)

Python 3.13+, Node 20+, and either Ollama or a free NVIDIA NIM API key. No Kubernetes, no cloud account — SQLite mode needs no database server at all.

git clone https://github.com/strikersam/autonomous-ai-agency.git && cd autonomous-ai-agency
python -m venv .venv && source .venv/bin/activate
pip install -r backend/requirements.txt
cp .env.example .env    # minimum: STORAGE_BACKEND=sqlite, SECRET_KEY, ADMIN_EMAIL/PASSWORD, NVIDIA_API_KEY
uvicorn backend.server:app --host 0.0.0.0 --port 8001
cd frontend && npm install && REACT_APP_BACKEND_URL=http://localhost:8001 npm start

Then open http://localhost:3000, paste your company URL, and onboard. Full setup, cloud deployment (Render + Cloudflare + GitHub Pages), and every configuration variable: docs/platform-guide.md · docs/configuration-reference.md

Screens

Captured from a live deployment. Regenerate with python scripts/capture_screens.py, then python scripts/sync_readme_gallery.py.

💬 Chat — unified assistant

Talk to the CEO agent directly; it decomposes goals and routes work to the right specialists.

📊 Dashboard — system overview

Live agent health, recent activity, and system metrics at a glance.

🗂 Tasks — job lifecycle board

Every AI job made visible: waiting, running, blocked, in review, or done.

🤖 Agents — autonomous team

Your specialist roster — each with its own model, runtime, specialty, and guardrails.

🗓 Schedules — autopilot jobs

Recurring and scheduled autonomous work.

⚡ Skills — agentic capabilities

Reusable runtime skills bound to specialists.

🎯 Portfolio — WSJF roadmap

Prioritised initiatives, sprints, and agile health.

📈 Intelligence — trends & competitors

Trend and competitor signals scoped to each onboarded company's stack.

📚 Knowledge — docs & sources

Wiki pages, source material, and reusable context — your team's memory.

🔌 Providers — models, Ollama & MCP

Connect free/cloud/local AI sources and choose which models are available.

🔭 Logs — traces & observability

Every LLM call: tokens, latency, cost, and decision context.

🐙 GitHub — repos & PRs

Connect repositories and manage the agent's delivery surface.

🏢 Company — operating context

An onboarded company's detected stack, systems, and SEO/health.

✨ Onboarding — setup wizard

Scan a website and stand up its specialist agency in minutes.

🔁 Loops — autonomous fleet

Every autonomous loop catalogued: readiness score, maturity, self-heal coverage, drift status, and cost estimate.

🩺 Doctor — diagnostics

System self-checks and autonomy readiness probes.

🛡 Admin — users & access

Manage users, roles, instance activation, and onboarding gates.

📱 Mobile

Responsive layout — sign in, view the dashboard, and work the task board from a phone.

Architecture, security, license

The stack is a React SPA (Cloudflare Worker / GitHub Pages) over a FastAPI backend (Render / Docker) with swappable MongoDB/SQLite storage, a ModelRouter for task-aware model selection, and a persisted workflow state machine with HITL gates — the full diagram and the honest feature-maturity matrix are in docs/platform-guide.md.

Security posture: no secrets in source (env-only, validated at startup) · JWT Bearer auth on every endpoint · three-role RBAC · per-task git worktree isolation · Bandit SAST + CodeQL + secret scanning on every push · dependency CVE audit on every PR · audit log for all admin actions.

MIT — see LICENSE

Contributing

Issues and PRs are welcome. CONTRIBUTING.md covers dev setup, coding standards, and the PR checklist; SECURITY.md covers vulnerability disclosure. Since most merged PRs here are agent-authored, the fastest way to see the expected quality bar is to read a few recent ones.

If you'd rather point an agent at a specific gap than write the fix yourself, open an issue describing it — the fleet's own inbound-issue triage may pick it up.

Autonomous AI Agency — the AI team that works while you sleep, on a server you own.

Built for engineers and operators who want the leverage of frontier AI without the cloud bill, the privacy compromise, or the headcount.

If this is useful to you, a star helps other people with the same problem find it.