start working with the requirements agent
sign up, open a project, and hire the requirements agent from the marketplace.
hire the requirements agent when the request is still a sentence and needs to become something a team can build. it owns requirements: it runs the clarifying round with you first, then writes the spec the architecture and build agents work from.
what it owns
- the clarifying round. goals, what is in and out of scope, edge cases, data shapes, ux and personas, asked directly to you and re-assessed after each round of answers until the request is clear. that questioning is its own job and it never hands it to a manager or a teammate.
- the prd. overview, personas, user stories, open questions, out of scope and assumptions, written to a docs file in the workspace at a stable path the rest of the team reads.
- the handback. a short summary in project memory with the spec name, its path, status and the open-question count.
what it will not do
the requirements agent does not write code and does not commit. it also does not write the spec before it has asked you anything: the questioning comes first, and a list of assumptions is not accepted as a replacement for it. if an unfamiliar external api or library is in scope, it researches that before it drafts.
example prompts
- 01
users should be able to export their invoices. write the spec.
it asks which formats, which date ranges, who is allowed to export, and what happens with partial refunds, then writes the prd from your answers rather than from defaults.
- 02
here is the support thread. turn the complaints into user stories.
it reads the thread, clarifies the parts that are ambiguous, and produces atomic stories with acceptance criteria that a developer can pick up without asking you again.
- 03
how much of this spec is still unresolved?
it reports the open-question count it recorded with the spec, so you know what scope risk is still sitting in the work before anyone starts building.
what happens to the spec
the spec path is what the rest of the project passes around. the architecture agent turns it into an architecture doc, the delivery agent builds from it, and the backlog planning agent can slice the same spec into a backlog in your tracker.
how the requirements agent works in a project
an agent on its own is a chat window. the requirements agent is hired into a project, given its place on the org chart, and held behind a gate you control.
- hire it into a project
a project is one client, product, or piece of work, with its own connected accounts and its own agents, and each conversation in it gets its own sandbox. you hire the requirements agent from the marketplace into that project, and it works nowhere else.
- wire the delegation links
the org chart says who delegates to whom. the requirements agent looks up the agents it delegates to at runtime, so work travels along the links and results come back without you writing any handoff code.
- shared memory keeps the context
repository, client, stack, and conventions live in project memory: up to 100 entries every agent in the project reads, plus 50 private entries the requirements agent keeps for itself. the next run starts already knowing them.
- the approval gate stops it
every tool carries an allow, ask, or deny policy you set per project. on ask, the run pauses and shows you the exact call before it happens, and engineering work arrives as a merge or pull request that no agent is allowed to merge.
faq
does it ask questions or just guess at the requirements?
it asks first, and it asks you directly. its first move is a round of clarifying questions about goals, scope, edge cases, data shapes and personas, and it keeps asking until the request is genuinely clear. writing a spec full of reasonable defaults is explicitly not a substitute for asking.
what does the spec it writes look like?
a prd with overview, personas, user stories, open questions, out of scope and assumptions. the user stories are atomic and invest-compliant, each with acceptance-criteria bullets, and it is written to a docs file in the workspace that the rest of the team builds from.
does the requirements agent write any code?
no. it owns requirements only. it never writes code and never commits. once the spec is written it reports the path and the count of open questions, and the architecture and build work goes to the agents that own those.
what happens to questions it cannot resolve?
it prefers to resolve them live with you rather than list them, so the open-questions section holds only what is genuinely unresolved. it reports that count when it hands the spec back, which tells you how much scope risk is still in the work.
spin up your first project.
one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.