start here

start using Nginx with your agents

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

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

nginx ai agent: write the config, test it on a live server

add nginx to a project's setup script and its agents write server blocks, validate the config, reload the service, and check what the proxy actually returns.

runs on
conversation sandbox
installed by
setup script
category
server

an nginx config is a program with unusual matching rules, and reading one is a poor way to find out what it does. installing nginx in each conversation's sandbox lets an agent write a block, reload, and observe.

what agents do with it

once the setup script has run, nginx is running in the conversation's sandbox. agents edit a server block, validate the syntax before reloading so a broken config never takes the service down, reload, and then call the endpoint from the same box to see the real response. the access and error logs are on the same filesystem, so when a request goes to the wrong upstream the agent reads which location matched rather than guessing at precedence.

proxying to something the project also runs

the useful pairing is nginx in front of an application the project is already running. with the runtime installed in the same project, an agent can start the app, put nginx in front of it, and verify headers, timeouts and upstream behaviour end to end without leaving the machine.

example tasks

  • 01

    requests to the api path are hitting the wrong upstream. fix the config.

    the agent edits the server block, validates it, reloads nginx in the conversation's sandbox, calls the path, and reads the access log to confirm which location matched.

    editbashread
  • 02

    add gzip and caching headers and prove they are being sent.

    it changes the config, reloads, and inspects the actual response headers from the same machine rather than asserting the directive is correct.

    editbashgrep

what to know before installing

the project needs a sandbox. nginx is light and sits comfortably on the small size beside an application. a setup script for it adds the nginx repository, installs the package, and enables the service.

how to install Nginx

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

  1. give the project a sandbox

    Nginx 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 Nginx'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 Nginx 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 Nginx 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 nginx on a project give the agents?

the nginx web server running in each conversation's own sandbox, with the config under its usual paths. agents write server blocks, validate them, reload the service, and then call the endpoint from the same box to see what the proxy actually returned.

why not just review the config by reading it?

because location matching and proxy headers are where nginx configs go wrong, and both are easier to observe than to reason about. an agent that can reload and curl finds the block that wins in half the time it would spend arguing about precedence.

is this a production web server?

no. it runs in each conversation's own sandbox for development and verification, one machine the conversation keeps to itself. we publish nothing from it and put no domain in front of it, so an agent is testing what the config does rather than running a site for anyone else.

does the config 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 config written today is still in place tomorrow. 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.

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.