start here

start using Redis with your agents

sign up, open a project, and add Redis to its setup script in settings → server.

Start 7-day trial with Redis
integrationstechnologyupdated
schematic diagram of the work aldena agents do through Redis
Redis

redis ai agent: a live cache and queue in each conversation's own sandbox

add redis to a project's setup script and its agents run redis-cli, inspect keys, exercise queues and rate limiters, and test the caching path on a real instance.

runs on
conversation sandbox
installed by
setup script
category
datastore

caching and queueing are the parts of a system that misbehave only under real conditions. installing redis in each conversation's sandbox means the agent working on that code can create those conditions rather than describe them.

what agents do with it

once the setup script has run, a redis server is running in the conversation's sandbox and redis-cli is on the path. agents point the application at localhost, exercise the cache path, and then inspect what actually landed: which keys exist, what their ttls are, whether the eviction they expected happened. for queue work they push jobs, watch the worker drain them, and read the payload of the one that failed.

why an instance beats a mock

a mocked cache agrees with whatever the code does, which is why cache bugs survive test suites. a real instance disagrees. an agent that can run redis-cli sees the key that was never set, the ttl that was written in seconds instead of milliseconds, and the lock that was never released, and can fix the cause rather than the symptom.

example tasks

  • 01

    the rate limiter lets too many requests through. find the bug.

    the agent runs the limiter against the project's redis, watches the keys and their ttls as requests arrive, and points at the window that is being reset instead of extended.

    bashreadedit
  • 02

    prove the cache invalidation actually works after an update.

    it writes a value, updates through the app, and checks the key with redis-cli, iterating in the conversation's sandbox until the behaviour matches what the code claims.

    bashgrep

what to know before installing

the project needs a sandbox. redis is small, so it sits comfortably beside an application on the small size. a setup script for it installs the package and enables the service, so redis comes back up each time the sandbox wakes.

how to install Redis

Redis goes in the project's setup script, not once per team and not on your laptop.

  1. give the project a sandbox

    Redis 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.

  2. 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 Redis's install commands there and save.

  3. 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.

  4. agents use it through bash

    from then on every agent in the project reaches Redis 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 Redis 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 redis on a project give the agents?

a running redis server and the redis-cli client in each conversation's sandbox. agents point the app at localhost, exercise the cache and queue paths for real, and inspect keys and ttls with redis-cli instead of asserting against a mock that always agrees with them.

is this shared with my other projects?

no. redis is installed per project, in each conversation's own sandbox, and two projects never share a filesystem. a flushed database in one cannot touch another, which is what makes it safe to let an agent experiment.

can agents test a background queue with it?

yes. with redis and the language runtime installed in the same project, an agent starts the worker, pushes jobs, watches them drain, and reads the failure when one does not. that whole loop happens in the conversation's sandbox through the bash tool.

does redis keep running after the sandbox sleeps?

enable the service in the setup script so it comes back up each time the sandbox wakes, and print redis-server --version at the end so the last run's output records what landed. a new conversation gets its own sandbox, and the setup script runs on it again.

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.