start using Docker with your agents
sign up, open a project, and add Docker to its setup script in settings → server.
on the docker ai agent search, docker owns most of the page with its own agent platform. this page is a smaller and more literal claim: docker is something a project's setup script installs in each conversation's sandbox, so the containers your app depends on are already running when its agents start work.
what agents do with it
agents run without sudo or docker, so they never call the docker cli themselves. the setup script runs with sudo, and it is where docker engine with the buildx and compose plugins gets installed, the images get built, and the stack comes up with docker compose up -d. agents work against what is running: they call the app on the port its container publishes, run the test suite against the database and the queue, and read the output of each command from the bash tool. they can write and edit a dockerfile or a compose file like any other file in the checkout, but building and running it stays with the setup script.
the matching skill
docker ships with a skill of the same name. skills load only for the agents you assign them to, so the engineer who works against the stack carries it and nobody else in the project does.
example tasks
- 01
run the integration tests against the compose stack.
the setup script already brought the database and the cache up in containers, so the agent points the suite at their published ports, runs it, and reads the failures from the output instead of guessing at them.
bashgrep - 02
the app can't reach the database. find out why.
it checks that the database container's published port answers from the conversation's sandbox, compares that with the app's connection settings, and fixes the config rather than the container.
bashreadedit
what to know before installing
the project needs a sandbox, and containers share its memory and disk, so the small size is fine for a small stack and standard or larger is the better choice for anything with a database in it. the setup script runs once on each new sandbox, so put the install, the image builds, and docker compose up -d there together. settings → server shows its last run, so a failed install surfaces its error instead of leaving the project in an unknown state.
how to install Docker
Docker goes in the project's setup script, not once per team and not on your laptop.
- give the project a sandbox
Docker runs in each conversation's sandbox, on your team's own sandbox provider account. an owner or admin connects a provider once on the team's providers page, then picks it and a default size for the project, at creation or later in settings → server. a project with no sandbox has nowhere to run it.
- add it to the setup script
settings → server holds the project's setup script, a bash script that runs once on each new sandbox, in /project, with sudo. add Docker's install commands there and save.
- the next sandbox runs it
the script runs when a conversation's sandbox is created or reused, on the conversation's first turn. settings shows the last run with its exit code and output, and a failed run leaves the sandbox usable rather than blocking the project.
- agents use it through bash
from then on every agent in the project reaches Docker with the bash tool, on the same filesystem as the checkout they are working in. the conversation's sandbox keeps it between turns, sleeping when idle and waking with the next one.
where Docker actually lives
each conversation in a project gets its own sandbox on your team's sandbox provider account, and the project's setup script in settings → server decides what is on it. two projects never share a filesystem, so a version pinned for one client cannot collide with another's.
the sandbox provider bills its machine time to your team's account while it runs, and aldena adds nothing. the sizes are on isolated projects, and what agents may run in the sandbox is governed by the project's tool permissions.
faq
is this a competitor to docker's own agent platform?
no, and it is worth being plain about it. docker here is installed in each conversation's sandbox by the project's setup script, the same way node or postgres is, and the setup script uses it to run your containers. docker's own agent products are a different thing entirely and are not involved.
what does installing docker on a project give the agents?
running services rather than a docker cli. the setup script runs with sudo, so it installs docker engine with the buildx and compose plugins, builds your images, and brings the stack up. agents run without sudo or docker, so they never call docker themselves: they reach the app, the database, and the queue on the ports your containers publish, from the bash tool.
can an agent bring up a multi-container stack for a test run?
not by itself, because agents have no docker access. put docker compose up -d in the setup script and the stack is already running when the agents start, so they run the test suite against it straight away. because each conversation gets its own machine, nothing collides with another project's ports or volumes.
what happens when the dockerfile or the compose file changes?
an agent can edit either one like any other file in the checkout, but it cannot rebuild or restart the stack. the setup script runs once on each new sandbox, so an owner or admin updates it in settings → server and starts a new conversation, whose sandbox runs the updated script.
what stops an agent from running something destructive?
agents run without sudo or docker, so a docker command from the bash tool is refused and the containers the setup script started stay as they are. what agents do run through bash is still a mutating tool call, so it stops for your approval unless the project allows it. a project's tool permissions can set bash to ask, allow, or deny outright, per project and per agent.
does the docker install survive between sessions?
only within a conversation. each conversation's sandbox keeps its files between turns, sleeping when idle and waking with the next one, so the images and volumes are still there. enable the docker service and give each container a restart policy such as unless-stopped, and the stack comes back up when the sandbox wakes. a new conversation gets its own sandbox, and the setup script runs on it again. a conversation left quiet for 7 days gives its sandbox back, and its next turn starts fresh.
spin up your first project.
one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.
