Quay — Autonomous AI Software Factory

Self-hosted AI agents that plan, code, review, security-scan, and deploy — with full cost transparency and an open architecture.

Quay is an open-source AI Software Factory — a platform for orchestrating autonomous AI agents through customizable pipelines. Agents write code, run reviews, perform security scans, and produce deployable artifacts — all with an open, self-hosted architecture and real-time observability.

✨ Features

🤖 Autonomous Agent Pipelines

Role-based agents: Engineer → Reviewer → Security → Deployer pipeline out of the box
Customizable stages: Swap, add, or remove pipeline stages to match your workflow
SWE-agent loop: Observe → Plan → Act → Reflect cycle with SQLite-backed step tracking

🔌 MCP Integration (Model Context Protocol)

Connect any MCP-compatible tool server via stdio (filesystem, git, Slack, custom tools)
First-class support for the Model Context Protocol — like USB for AI agents
Lazy-loaded per pipeline stage; hot-reload on server restart

💰 Cost Transparency

Every LLM call logged with token counts and cost in USD
Per-task, per-project, and global cost dashboards
Route through A3M Router for adaptive multi-provider routing (OpenAI, Anthropic, Groq, Ollama, and 40+ more)

🛡️ Self-Hosted & Open

No vendor lock-in — run entirely on your own infrastructure
Bearer-token auth with configurable QUAY_API_KEY
Full audit trail: every state transition, every tool call, every run — logged to SQLite

📊 Mission Control Dashboard

Real-time dark UI with KPI cards (success rate, active agents, pipeline health, daily cost)
Kanban board (7 states: Backlog → Queued → In Progress → Review → Done / Failed / Blocked)
Live activity feed via SSE streaming
Mock/Live data toggle for development

🧠 Three-Tier Agent Memory

Short-term: Per-run cache (30-minute TTL, in-memory Map)
Medium-term: 7-day lessons learned per project
Long-term: Agent capability/failure graph with success-rate weighting

📡 Real-Time Streaming

Server-Sent Events for task lifecycle broadcasts
WebSocket-ready architecture
Zero polling — dashboard updates on every state change

📊 Competitive Comparison

Quay sits at the intersection of enterprise capability and open-source flexibility — self-hosted, cost-transparent, and built for teams that want full control without building from scratch.

How to Read the Table

Symbol	Meaning
✅ Full support	Available and production-ready
⚠️ Partial / Limited	Available but with constraints
❌ Not available	Not supported or not applicable

Platform Comparison

21 platforms compared across 13 parameters — platforms as rows for readability.

Platform	Type	Deploy	Pricing	LLM Flex	MCP	Cost Transp	Dashboard	State Mach	Audit	Auto Code	Pipeline	Multi-Agent	Open Src
Quay	Factory	✅ Self	✅ MIT	✅ Any (40+)	✅ Native	✅ Per-call	✅ Live SSE	✅ 7-state	✅ SQLite	✅ Prod	✅ Full	✅ Role	✅ MIT
XHawk OpenFactory	Factory	❌ Cloud	⚠️ Opaque	⚠️ Prop	❌	❌ Opaque	⚠️ Dash	⚠️ Basic	⚠️ Logs	✅ Prod	⚠️ Config	⚠️ Multi	❌ Prop
ServiceNow AI Agents	Enterprise	❌ Cloud	⚠️ Opaque	⚠️ Prop	⚠️ Integr	⚠️ Agg	⚠️ Now UI	✅ Full	✅ Full	⚠️ Auto	⚠️ Flow	⚠️ Virt	❌ Prop
Copilot Studio	Enterprise	❌ Cloud	⚠️ Per-seat	⚠️ Copilot	⚠️ Conn	⚠️ Admin	✅ Power	✅ Flows	✅ Full	⚠️ Prompt	⚠️ Studio	⚠️ Auto	❌ Prop
Einstein Agent	CRM	❌ Cloud	⚠️ Per-agent	⚠️ Einst	⚠️ APIs	⚠️ CRM	⚠️ SF UI	⚠️ Case	✅ Full	⚠️ Case	⚠️ Flow	⚠️ Einst	❌ Prop
Workato	iPaaS+AI	⚠️ Hybrid	⚠️ Per-job	⚠️ Wkto	⚠️ 200+	⚠️ Conn	⚠️ Rpter	⚠️ Job	✅ Full	⚠️ Recipe	⚠️ Low	⚠️ Recipe	⚠️ Src
Automation Anywhere	RPA+AI	⚠️ On-prem	⚠️ Bot	⚠️ Insight	⚠️ Integr	⚠️ Analytics	⚠️ Room	⚠️ Attend	✅ Full	⚠️ Attend	⚠️ RPA	⚠️ RPA	❌ Prop
MultiOn	Browser AI	❌ Cloud	⚠️ API	✅ Any	❌	⚠️ API	⚠️ API	⚠️ Basic	❌	⚠️ Browser	⚠️ Browser	❌	⚠️ Freem
Adept ACT-1	Ent AI	❌ Cloud	⚠️ Ent	✅ Any	❌	❌ Opaque	⚠️ Portal	⚠️ Task	⚠️ Ent	⚠️ Multi	⚠️ ACT-1	⚠️ Ent	❌ Prop
Airkit	CX AI	❌ Cloud	⚠️ Seat	⚠️ Airkit	❌	⚠️ CC	⚠️ Studio	⚠️ Bot	⚠️ Sess	❌	⚠️ Builder	❌	⚠️ Freem
Embra	Know AI	❌ Cloud	⚠️ Seat	✅ Multi	❌	❌ Opaque	⚠️ Space	❌	⚠️ Logs	⚠️ Know	❌	❌	⚠️ Freem
Corr	AI Agent	❌ Cloud	⚠️ Seat	✅ Multi	⚠️ Roadmap	❌ Opaque	⚠️ Dash	⚠️ Queue	⚠️ Basic	⚠️ Gen	⚠️ Config	⚠️ Multi	⚠️ Beta
Superagent	OSS Agent	✅ Self	✅ MIT	✅ Any	⚠️ Tools	⚠️ Back	⚠️ LangS	⚠️ Custom	⚠️ Custom	⚠️ Tool	⚠️ Config	⚠️ Single	✅ MIT
Jina AI	Infra	⚠️ Hybrid	⚠️ Per-call	✅ Any	⚠️ Proxy	⚠️ Pro	⚠️ Dash	❌	⚠️ API	⚠️ Read	⚠️ Svc	⚠️ Read	⚠️ Partial
MindOS	Agent Plat	❌ Cloud	⚠️ Sub	⚠️ MindOS	⚠️ Plugins	❌ Opaque	✅ Portal	⚠️ Agent	⚠️ Sess	⚠️ Know	⚠️ Builder	⚠️ Multi	⚠️ Freem
AutoGen	OSS Frame	✅ Self	✅ MIT	✅ Any	⚠️ Tools	❌	❌	❌	⚠️ Console	⚠️ Rsrch	⚠️ Code	⚠️ Conv	✅ MIT
CrewAI	OSS Multi	✅ Self	✅ MIT	✅ Any	⚠️ Tools	⚠️ LangS	⚠️ LangS	⚠️ Crew	⚠️ LangS	⚠️ Role	⚠️ YAML	⚠️ Role	✅ MIT
LangGraph	OSS Workfl	✅ Self	✅ Apache	✅ Any	⚠️ LC	⚠️ LangS	⚠️ LangS	⚠️ Check	⚠️ LangS	⚠️ Workfl	⚠️ Graph	⚠️ Graph	✅ Apache
MetaGPT	OSS Dev	✅ Self	✅ MIT	⚠️ GPT4	❌	❌	❌	❌	⚠️ Console	⚠️ Dev	⚠️ Role	⚠️ Prompt	✅ MIT
OpenDevin	OSS Code	✅ Self	⚠️ AGPL	✅ Any	⚠️ Plugins	❌	⚠️ Web UI	⚠️ Loop	⚠️ Events	⚠️ SWE	⚠️ AgentG	⚠️ Event	⚠️ AGPL
SWE-agent	OSS SWE	✅ Self	✅ Apache	✅ Any	❌	❌	❌ CLI	❌	⚠️ Term	⚠️ CLI	⚠️ CLAUDE	❌	✅ Apache
Continue Dev	OSS IDE	✅ Local	✅ Apache	✅ Any	⚠️ Config	❌	⚠️ IDE	❌	⚠️ IDE	⚠️ IDE	⚠️ Config	⚠️ Pair	✅ Apache
Moss	OSS Code	✅ Self	✅ MIT	✅ Any	⚠️ Tools	❌	⚠️ Web	⚠️ Basic	⚠️ Hist	⚠️ Gen	⚠️ Miss	⚠️ Miss	✅ MIT

Why Teams Choose Quay

vs. Open-Source Frameworks (AutoGen, CrewAI, MetaGPT, OpenDevin)

AutoGen, CrewAI, LangGraph, MetaGPT, and OpenDevin are powerful research-grade tools — but they're frameworks, not platforms. You still need to build: auth, a dashboard, state persistence, cost tracking, and deployment pipelines. Quay provides all of that out of the box with a production-ready UI.

Capability	AutoGen/CrewAI/MetaGPT	Quay
Production dashboard	❌	✅ Live SSE + Kanban
Task state machine	❌	✅ 7-state with transitions
Cost per LLM call	❌	✅ Per-call USD logging
MCP native support	⚠️ Via custom tools	✅ Native stdio registry
SQLite audit trail	❌	✅ Full schema
Self-hosted	✅	✅
Zero-config start	❌	✅ `bun run scripts/seed.ts`

vs. XHawk OpenFactory

XHawk is the closest commercial equivalent — but it's cloud-only with opaque enterprise pricing and no self-hosted option. If your team has compliance requirements (GDPR, SOC2, data residency), XHawk may not be an option.

Capability	XHawk OpenFactory	Quay
Self-hosted	❌ Cloud-only	✅ Run on your infra
Cost transparency	❌ Opaque	✅ Per-call USD logging
Audit trail	⚠️ Logs	✅ Full SQLite schema
MCP support	❌	✅ Native
Pricing	Enterprise (opaque)	✅ MIT (open source)
Customization	⚠️ Configurable	✅ Full pipeline code

vs. Enterprise Platforms (ServiceNow, Copilot Studio, Einstein)

ServiceNow AI Agents, Microsoft Copilot Studio, and Salesforce Einstein Agent are locked to their respective ecosystems — great if you live in those platforms, expensive and restrictive otherwise. Quay integrates with any LLM provider via A3M Router and any MCP tool server.

Capability	ServiceNow / Copilot Studio / Einstein	Quay
Non-proprietary LLMs	❌	✅ Any via A3M
MCP tool servers	⚠️ Via integration	✅ Native
Self-hosted	❌	✅
Transparent pricing	❌ Enterprise quote	✅ Open source
Custom pipeline stages	⚠️ Flow Designer	✅ Any stage, any code
Data residency	❌ Cloud-only	✅ Full control

vs. Startups (MultiOn, Adept, Airkit, Embra, Corr)

Most AI agent startups are either browser-focused (MultiOn), enterprise-SaaS with opaque pricing (Adept, Corr), or narrow-use-case (Airkit). Quay is the only open-source option with a full production software factory — complete state machine, real-time dashboard, audit trail, MCP, and cost logging — without vendor lock-in.

Scoring Summary

Based on the comparison across 13 key parameters:

Category	Quay Score	Best Open Source	Best Enterprise
Deployment flexibility	10/10 ✅	10/10 (AutoGen, CrewAI)	4/10 (ServiceNow)
LLM flexibility	10/10 ✅	10/10 (Quay, AutoGen)	3/10 (Copilot Studio)
MCP integration	10/10 ✅	5/10 (CrewAI)	3/10 (ServiceNow)
Cost transparency	10/10 ✅	0/10 (AutoGen, OpenDevin)	2/10 (XHawk)
Real-time dashboard	9/10 ✅	3/10 (OpenDevin)	6/10 (Copilot Studio)
Task state machine	10/10 ✅	0/10 (most OSS)	7/10 (ServiceNow)
Audit trail depth	10/10 ✅	2/10 (LangGraph)	8/10 (ServiceNow)
Autonomous coding	9/10 ✅	8/10 (OpenDevin)	6/10 (XHawk)
Pipeline customization	10/10 ✅	7/10 (CrewAI)	5/10 (Workato)
Multi-agent support	8/10 ✅	7/10 (MetaGPT)	7/10 (XHawk)
Open source	10/10 ✅	10/10 (Quay, AutoGen)	0/10
Production readiness	8/10 ✅	4/10 (OpenDevin)	8/10 (ServiceNow)
Total	114/130	~58/130 (best OSS)	~58/130 (best ent)

Quay is the only platform that combines: self-hosted deployment + any LLM via A3M Router + native MCP + per-call cost transparency + full state machine + real-time dashboard + open source MIT license.

🚀 Quick Start

Prerequisites

Bun ≥ 1.0 or Node.js ≥ 18
SQLite (built-in via bun:sqlite)

Install

git clone https://github.com/Das-rebel/quay.git
cd quay
bun install

Seed the Database

bun run scripts/seed.ts

Start the API Server

bun run src/server/index.ts
# → http://localhost:3001
# → Health: http://localhost:3001/health
# → API key: quay-dev-key (development only)

Start the Dashboard

npm run dev
# → http://localhost:5173

Configure MCP Servers (optional)

export QUAY_MCP_SERVERS='[{"name":"filesystem","command":"npx","args":["-y","@modelcontextprotocol/server-filesystem","/tmp"]}]'
bun run src/server/index.ts

🏗️ Architecture

quay/
├── src/
│   ├── server/
│   │   ├── index.ts          # Hono API + auth middleware + all routes
│   │   ├── db/
│   │   │   ├── schema.ts     # Drizzle schema (7 tables)
│   │   │   └── index.ts      # bun:sqlite wrapper (dbq)
│   │   ├── agents/
│   │   │   └── agentRunner.ts # SWE-agent: observe→plan→act→reflect loop
│   │   ├── pipeline/
│   │   │   └── pipeline.ts   # Role-based executor: engineer→reviewer→security
│   │   ├── memory/
│   │   │   └── memoryTree.ts  # 3-tier memory + knowledge graph
│   │   ├── mcp/
│   │   │   └── index.ts       # MCP stdio registry + tools/call
│   │   └── sse/
│   │       └── index.ts       # SSE broadcaster + heartbeat
│   ├── routes/
│   │   └── +page.svelte      # Mission Control dashboard (dark UI)
│   └── lib/
│       └── stores/
│           └── quay.ts        # Svelte stores + API helpers
├── scripts/
│   └── seed.ts               # Seed script with sample project/tasks/agents
├── quay.db                    # SQLite database (gitignored)
└── drizzle.config.ts

API Endpoints

Method	Path	Description
`GET`	`/health`	Health check (no auth)
`GET`	`/sse`	SSE stream (no auth)
`GET`	`/api/projects`	List all projects
`POST`	`/api/projects`	Create project
`GET`	`/api/projects/:id/tasks`	List tasks for project
`POST`	`/api/projects/:id/tasks`	Create task
`GET`	`/api/projects/:id/kanban`	Kanban view (7 columns)
`POST`	`/api/tasks/:id/transition`	Trigger state transition
`POST`	`/api/tasks/:id/run`	Run pipeline on task
`GET`	`/api/agents`	List all agents
`PATCH`	`/api/agents/:id/status`	Update agent status
`GET`	`/api/stats`	Global dashboard stats
`POST`	`/api/test-event`	Broadcast SSE test event
`GET`	`/api/mcp/tools`	List registered MCP tools

Task State Machine

BACKLOG → QUEUED → IN_PROGRESS → REVIEW → DONE
    ↓         ↓          ↓         ↓
  (SUBMIT) (ASSIGN) (STEP_COMPLETE) (APPROVE)
                  ↓              ↓
               FAILED ←←←←←←← (REJECT)
                  ↓
               (RETRY)
                  ↓
               QUEUED

BLOCKED ← (can block from REVIEW)
  ↓
(UNBLOCK) → QUEUED

🔧 Configuration

Environment Variable	Default	Description
`QUAY_API_KEY`	`quay-dev-key`	Bearer token for API auth
`QUAY_PORT`	`3001`	API server port
`QUAY_MCP_SERVERS`	`[]`	JSON array of MCP server configs

MCP Server Config Format

[
  {
    "name": "filesystem",
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
  },
  {
    "name": "git",
    "command": "uvx",
    "args": ["mcp-server-git", "--repository", "/path/to/repo"]
  }
]

🤖 Marketic MCP Integration

Quay integrates with Marketic (Marketing Intelligence OS) as a native MCP tool provider, enabling autonomous marketing pipelines alongside code agents.

Architecture

Quay Mission Control Dashboard
         ↓
   Agent Runner
         ↓
   MCP Registry
         ↓
Marketic MCP Server ←→ Marketing Intelligence Tools
                            ↓
    ┌───────────────────────┼───────────────────────┐
    ↓                       ↓                       ↓
Competitive Analysis   Creative Generation    Campaign Management
(analyze_competitor)   (generate_creatives)   (build_campaign)
(compare_competitors)  (generate_social)     (optimize_budget)
(analyze_positioning)  (generate_seo)       (launch_campaign)
                         ↓
              Analytics & Attribution
              (get_attribution)
              (collect_signals)

Available Marketing Tools

Category	Tools	Description
Competitive Analysis	`analyze_competitor`, `compare_competitors`, `analyze_positioning`	Deep-dive competitor research and positioning
Creative Generation	`generate_creatives`, `generate_social_posts`, `generate_seo_content`, `generate_narrative`	Ad copy, social content, SEO articles
Campaign Management	`build_campaign`, `optimize_budget`, `launch_campaign_ad`	Multi-channel campaign planning and optimization
Analytics	`get_attribution`, `collect_signals`	Attribution modeling and market intelligence
Hub Connectors	`hub_*` (9 tools)	WebEngage, HubSpot, CleverTap, Braze, Mailchimp integration
CRM	`crm_*` (8 tools)	Lead/deal management, activity logging

API Routes

Method	Path	Tool	Description
`POST`	`/api/marketing/analyze`	`marketic::analyze_competitor`	Competitor analysis
`POST`	`/api/marketing/creatives`	`marketic::generate_creatives`	Ad creative generation
`POST`	`/api/marketing/campaign`	`marketic::build_campaign` / `launch_campaign_ad`	Campaign build/launch
`POST`	`/api/marketing/signals`	`marketic::collect_signals`	Market intelligence
`POST`	`/api/marketing/performance`	`marketic::get_attribution`	Attribution analysis

Quick Test

# Analyze a competitor
curl -X POST http://localhost:3001/api/marketing/analyze \
  -H "Authorization: Bearer quay-dev-key" \
  -H "Content-Type: application/json" \
  -d '{"brand": "HubSpot", "category": "marketing automation"}'

# Generate campaign creatives
curl -X POST http://localhost:3001/api/marketing/creatives \
  -H "Authorization: Bearer quay-dev-key" \
  -H "Content-Type: application/json" \
  -d '{"competitor": "Quay AI Factory", "count": 5}'

Dashboard

The Marketing Intelligence dashboard is available at /marketing with:

Competitor analysis interface
Creative generator
Campaign builder
Market signals feed
Performance attribution

Integration Tests

cd quay
npm test -- tests/integration/
# 67 tests: 43 Marketic MCP + 24 API route contracts

Note: Marketic MCP server must be running for marketing tools to function. See Marketic for setup instructions.

📦 Tech Stack

Layer	Technology
API Server	Hono + Bun
Database	SQLite via Drizzle ORM + `bun:sqlite`
Dashboard	SvelteKit 5 (runes)
AI Routing	A3M Router
Agent Protocol	Model Context Protocol (MCP)
Task Queue	BullMQ + Redis
Streaming	Server-Sent Events (SSE)
Validation	Zod

📈 Roadmap

v0.2 — MCP server registry UI in Mission Control (MCP tools via /api/mcp/tools)
v0.2.1 — Marketic MCP integration (32 marketing intelligence tools)
v0.3 — GitHub/GitLab webhook triggers for automatic task creation
v0.4 — Docker sandbox execution for agent isolation
v0.5 — Kubernetes operator for multi-tenant deployment
v1.0 — Production hardening: rate limiting, OAuth2, HA mode

🤝 Contributing

Contributions are welcome. Please read CONTRIBUTING.md before opening PRs.

Fork the repository
Create your feature branch (git checkout -b feat/your-feature)
Run tests (bash scripts/test-quay.sh)
Commit and push
Open a Pull Request

📄 License

MIT License — see LICENSE

Name		Name	Last commit message	Last commit date
.github		.github
.vscode		.vscode
docs		docs
job_pipeline/decisions		job_pipeline/decisions
public		public
scripts		scripts
src		src
static		static
tests/integration		tests/integration
.gitignore		.gitignore
.nojekyll		.nojekyll
.npmrc		.npmrc
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
INTEGRATION.md		INTEGRATION.md
LICENSE		LICENSE
PRESS_RELEASE.md		PRESS_RELEASE.md
README.md		README.md
SOCIAL.md		SOCIAL.md
SUBMISSIONS.md		SUBMISSIONS.md
_config.yml		_config.yml
bun.lock		bun.lock
discoverability-diagnosis.md		discoverability-diagnosis.md
drizzle.config.ts		drizzle.config.ts
llms-full.txt		llms-full.txt
llms.txt		llms.txt
package-lock.json		package-lock.json
package.json		package.json
svelte.config.js		svelte.config.js
tsconfig.json		tsconfig.json
vite.config.ts		vite.config.ts
vitest.config.ts		vitest.config.ts

Latest commit

History

Folders and files

Repository files navigation