Your AI development team.
You don't hire engineers, wait on a backlog, or manage a project. You describe what you want, and eight AI agents — the same roles a real software company has — collaborate automatically to build it, with three automated engineering stages verifying, delivering and orchestrating the work around them.
Every role, on shift, on every build.
These are not personas on a marketing page. Each one maps to a stage that executes in production, with a defined role, a permission boundary, and specific tools. You can read the whole roster over the API at /api/agents and any single member's exact permissions at /api/agentic/permissions/<agent>.
Two kinds of teammate do that work, and we label which is which rather than blur them. AI means a real Claude model call decides the output — eight of them. Automated means deterministic code with real authority but no model — three of them, including the QA stage that can block a delivery outright. Both are genuinely running; they are not the same thing, and calling deterministic automation "AI" would be the easy lie.
AI Product Manager
Reads your idea before a single credit is spent and asks the few sharp questions that decide whether the build hits what you actually meant.
AI Software Architect
Turns the clarified idea into a structured spec — product name, features, pages, tech stack, and the data model every other agent builds against.
AI Backend Engineer
Writes the Express server: real REST routes, authentication, payments where needed, and the in-app AI agent your users will talk to — against a fixed security baseline.
AI Frontend Engineer
Builds the landing page and the application UI — responsive, clean, and held to an honesty rule: no invented user counts, ratings, testimonials or compliance badges.
AI Database Engineer
Designs the Postgres schema from the architect's data model, with row-level security on every table so each user can only ever reach their own rows.
AI QA Engineer
Runs every build through deterministic checks — syntax, completeness, route consistency, real-AI verification, security heuristics — and blocks broken code from ever reaching you.
AI Staff Engineer
Fixes what QA catches and revalidates the fix. A repair that fails verification is discarded rather than shipped — the build is flagged and your credits come back.
AI DevOps Engineer
Packages the finished project into a private GitHub repository and provisions a live preview when you ask for one.
AI Support Engineer
Stays on after delivery. Ask questions about your app, or ask for a change in plain English — it edits the real code and revalidates before anything replaces what you had.
Agent Manager
Resolves each build into a task graph, runs it, routes approvals to a human, and records the trace. Deliberately holds no build capability of its own.
Monitoring Agent
Watches the platform itself — failure rates, stuck builds, latency regressions, audit integrity. Detection is deterministic; when something is actually wrong it reasons over the findings with a model call to name the likely root cause, then escalates to a human with evidence and a proposed fix.
How they hand off.
The team isn't a queue of prompts. It's a task graph: the Agent Manager plans it, independent work runs in parallel, and each handoff is a checked contract rather than a hopeful function call. Every stage is timed, logged and replayable.
Your idea
└─ Product Manager clarifies intent
└─ Architect designs the blueprint
├─ Backend Engineer ┐
├─ Frontend Engineer ├─ in parallel
└─ Database Engineer ┘
└─ QA Engineer verifies — blocks anything broken
└─ Staff Engineer repairs and revalidates
└─ DevOps packages and delivers
└─ Support Engineer answers and edits, on request
└─ Monitoring watches, diagnoses, escalates
└─ You vision, governance, approvals
Humans own the irreversible. Agents propose; people decide. Platform deploys, database migrations, billing changes and data deletion are permanently human-only — not by convention, but because the permission system refuses to grant those capabilities to any agent. The most an agent can do is ask.
Who joins next.
The roadmap is inspectable through the same API as the live workforce, marked planned so there's never any doubt about what exists today:
We don't list an agent as active until it does real work in production. A roster padded with roles that don't run yet would make this page longer and the product no better.
Your users get an agent too.
The team above builds your software. Inside the software they build, there's another agent — one that works for your users. Every application AppMaking generates ships a real, working POST /api/agent/chat endpoint: a genuine model call, behind authentication, scoped by row-level security to that user's own data, documented in an AGENTS.md file so you can extend it.
That's what makes the output an Agentic Application rather than a generated CRUD app.
Put the team to work.
Describe your idea in a few English words. Your AI workforce takes it from there.