start here

start working with the delivery agent

sign up, open a project, and hire the delivery agent from the marketplace.

Start 7-day trial with the delivery agent
agentsDeliveryupdated
Delivery

ai engineering manager: delegates the build and opens the pull request

the delivery agent runs the pipeline. it delegates architecture, build, tests and review one at a time, then opens the pull request you review.

hired per
project
model
your choice

hire the delivery agent when you want delivery run rather than requested. it takes a spec and drives it through architecture, build, tests, review and fixes, delegating every step, and hands you a pull request at the end.

what it owns

  • the pipeline. architecture first if the architecture agent is hired, then the build, then backend tests followed by frontend tests, then review, then fixes split by lane. review and fix repeat up to two rounds, and stop early when a pass finds nothing critical or high.
  • sequencing. one delegate at a time, always. it dispatches, waits for the reply, then dispatches the next.
  • the git step. branching, committing, pushing, and opening the merge or pull request through whichever code-hosting integration the project has connected.
  • its own state. it keeps a delivery-state note in memory, updated after every delegate's reply, so it can resume the pipeline mid-flight without losing the thread.

what it will not do

the delivery agent never writes or edits code, never scaffolds a project, and never merges. told directly to build something itself, it still delegates. on any delegate failure it halts and tells you why rather than pushing a branch it knows is broken.

example prompts

  • 01

    the spec is approved. drive it to a pull request.

    it runs architecture, build, tests, review and fixes through its delegates one at a time, then branches, commits, pushes and opens the pull request with a summary.

  • 02

    where is the checkout work up to?

    it reads back its delivery-state note: which phase it is in, which lanes are done, which review iteration it is on, and the request url once there is one.

  • 03

    the code review agent found three high findings. get them fixed.

    it splits the findings into backend and frontend lanes, delegates each in sequence, and re-runs review until the diff is clear of critical and high findings.

who it delegates to

the delivery agent is only as good as the agents it delegates to on the org chart. the usual shape is the architecture agent, the backend build and frontend build agents or a single full-stack build agent, and the code review agent on its own link.

how the delivery agent works in a project

an agent on its own is a chat window. the delivery agent is hired into a project, given its place on the org chart, and held behind a gate you control.

  1. 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 delivery agent from the marketplace into that project, and it works nowhere else.

  2. wire the delegation links

    the org chart says who delegates to whom. the delivery 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.

  3. 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 delivery agent keeps for itself. the next run starts already knowing them.

  4. 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 an ai engineering manager write any of the code here?

no. the delivery agent delegates every line of implementation and refuses to pick the work up even when told to directly. the only hands-on step it does is the last one: branch, commit, push and open the merge or pull request.

how does it decide who gets the work?

by capability, resolved at runtime from the agents it delegates to. if a full-stack build agent is among them it can hand over the whole feature; otherwise it splits backend and frontend. if a capability is missing it reports that gap upward instead of building it itself.

does it run agents in parallel?

never. delegates run strictly one at a time: dispatch one, wait for the reply, then dispatch the next. running two on the same workspace is how teammates clobber each other's work, so the pipeline is sequential by design.

who merges the pull request?

you do. it opens the request against the default branch and stops there, because that open request is your review gate. it also halts the whole pipeline on any delegate failure rather than pushing a broken branch.

ready when you are

spin up your first project.

one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.