ai agent roster: eleven prebuilt agents you hire into a project
aldena ships agents named for the jobs a delivery team needs, from requirements to code review to bug fix. hire the ones you want and pick each one's runtime and model.
a prebuilt ai agent role is an agent that arrives with a job already defined: what it owns, what it refuses to do, and who it hands work to. aldena ships eleven of them, each named for the job it does, each with its own working instructions. you are not writing personas from scratch and you are not talking to one general assistant wearing different hats: you hire the agents a project needs and leave the rest on the shelf.
the roster
| agent | what it owns |
|---|---|
| Project Setup | runs the project, records its client and stack facts, sets the workspace up |
| Intake | the front door for requests, routes them, reports results back to you |
| Requirements | asks the clarifying questions, then writes the spec with acceptance criteria |
| Backlog Planning | slices an approved spec into work items and pushes the backlog to your tracker |
| Architecture | turns requirements into a buildable architecture: components, data model, contracts |
| Delivery | delegates the build, drives the review loop, commits and opens the pull request |
| Backend Build | schema, migrations, services, endpoints, and the tests behind them |
| Frontend Build | pages, components, state, and forms, wired to the real backend |
| Full-Stack Build | one feature end to end across both lanes when you would rather not split it |
| Code Review | reviews the diff across five lenses and reports findings, never edits code |
| Bug Fix | reproduces the failure, fixes the root cause, pins it with a regression test |
the agents are opinionated on purpose. the requirements agent asks before it writes. the delivery agent never writes code itself, only delegates and then opens the pull request. the code review agent never edits what it reviews. those boundaries are what make a hand-off mean something.
every agent picks its own runtime and model
each agent runs on a runtime: your team's own anthropic, openai or openrouter api key, or claude code or codex inside the project's sandbox. when you hire an agent, aldena suggests a runtime, a model and an effort for it, and you can change any of them before hiring or later in the agent's detail.
claude code runs on each member's own claude plan, signed in once per project in settings → runtimes, or on your team's anthropic key for everyone who has not signed in. codex runs on your team's openai key. the provider bills that usage to your account directly, and aldena adds nothing on top.
model choice is per agent, not per account. run the code review agent on a heavyweight reasoning model and the project setup agent on something cheap and fast, then change your mind next week. each agent also carries a reasoning effort, from low up to max, so you can spend more thinking where it pays.
every supported model, with its provider's list rate, is on the model pricing page, so the cost of a swap is something you can look up before you make it.
custom agents when the roster runs out
build your own from the same parts: a name, an animated avatar (one of 30 faces), up to 8000 characters of instructions, and the runtime and model you choose. custom agents behave like the prebuilt ones everywhere else, and they are versioned, so editing one keeps the history and you can go back to an earlier version. promote a custom agent to the team and any project can hire it.
how the roster becomes a team
hiring is only half of it. the agents you hire get a reporting structure on the org chart, each keeps what it learns in agent memory, they carry the skills you attach, and everything they do in your accounts passes the approval gate first.
faq
do i have to hire all eleven?
no. a project with the requirements agent, one build agent, and the code review agent is a normal starting team. hire more when a hand-off you keep doing by hand should belong to someone.
how are these different from one assistant with different prompts?
each agent has its own instructions, its own memory, its own model, and its own place in the org chart. they hand work to each other and report back, which one context switching hats cannot do.
can i change what an agent does?
yes. adjust its runtime, model and effort, attach skills, or build a custom agent with your own instructions when no shipped agent does the job you want.
can an agent run on my claude plan?
yes, in a project with a sandbox. sign your claude plan into claude code in the project's settings → runtimes, and the turns you start and the automations you create run on it. teammates use their own login or the project's shared runtime on the team's anthropic key. chatgpt plans are not supported yet.
what if two projects need the same custom agent?
promote it to the team. it becomes available to every project, and each project hires its own copy with its own memory.
which agent talks to me?
any of them. you can message an agent directly, and in a project with a hierarchy you usually talk to the top of it and let the work travel down.
spin up your first project.
one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.