start using RabbitMQ with your agents
sign up, open a project, and add RabbitMQ to its setup script in settings → server.
message queue bugs are delivery bugs, and delivery is what a fake broker gets wrong. installing rabbitmq in each conversation's sandbox means an agent can publish a message and watch what actually happens to it.
what agents do with it
once the setup script has run, the broker is running in the conversation's sandbox and rabbitmqctl is on the path. agents publish into an exchange, run the app's consumer, and inspect queues, bindings and unacknowledged counts. when a message does not arrive they check whether the routing key matched the binding rather than adding logging and hoping. when a retry loops forever they watch the dead letter path do its job or fail to.
proving the failure path
the useful test is not the happy one. an agent can kill a consumer mid-message in the conversation's sandbox and confirm the message is redelivered, or acknowledge early on purpose and show the message being lost. those are experiments a live broker allows and a mock cannot.
example tasks
- 01
messages are disappearing between the publisher and the worker. find out where.
the agent publishes on the project's broker, inspects the bindings and queue depths with rabbitmqctl, and shows the routing key that matches nothing.
bashreadedit - 02
prove the retry and dead letter setup actually works.
it publishes a message that fails on purpose, watches the redeliveries in the conversation's sandbox, and confirms where the message lands after the limit.
bashgrep
what to know before installing
the project needs a sandbox, and the broker plus erlang plus an application is a case for the standard size or larger. the erlang packages make it one of the longer installs, and settings → server shows the setup script's output from its last run.
how to install RabbitMQ
RabbitMQ goes in the project's setup script, not once per team and not on your laptop.
- give the project a sandbox
RabbitMQ 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 RabbitMQ'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 RabbitMQ 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 RabbitMQ 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
what does installing rabbitmq on a project give the agents?
a running rabbitmq broker in each conversation's own sandbox, with rabbitmqctl on the path. agents publish messages, run the app's consumers, and inspect queues, bindings and unacknowledged counts instead of reasoning about them.
why does message work need a real broker?
because the failures are in the delivery semantics. a message that is acknowledged too early, a binding that does not match the routing key, a dead letter exchange that was never declared. all three are visible on a live broker and invisible in a unit test with a fake.
does it need erlang too?
yes. the setup script installs the erlang packages rabbitmq needs before the broker itself, then enables the service and checks that it is running. that is the heaviest part of the script, and it runs once on each new sandbox rather than on every turn.
does the queue state 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 a declared exchange is still declared next time. 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.
