start here

start using Apache with your agents

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

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

apache ai agent: agents that edit the vhost and check what it serves

add the apache http server to a project's setup script and its agents edit virtual hosts, enable modules, restart the service, and check what a request returns.

runs on
conversation sandbox
installed by
setup script
category
server

apache configuration is layered: a main config, virtual hosts, enabled modules, and directory blocks that can each override the last. installing apache in each conversation's sandbox means an agent can find out which layer won by asking the server.

what agents do with it

once the setup script has run, apache is running in the conversation's sandbox and apache2ctl is on the path. agents edit a virtual host, check the syntax before restarting, restart, and then request the url from the same box. the error and access logs sit on the same filesystem, so a 403 becomes a specific directory directive rather than a guess, and a rewrite that misfires shows which rule matched.

the case for a live server

rewrite rules, module ordering and per-directory overrides are the three parts of apache that reading cannot settle. an agent that can enable a module, restart, and make a request resolves all three by observation, on a machine nobody else depends on.

example tasks

  • 01

    the rewrite for the legacy urls is not firing. work out why.

    the agent checks the module is enabled, applies the rule, restarts apache in the conversation's sandbox, requests the old url, and reads the log to see which rule matched.

    editbashread
  • 02

    the static directory returns 403. fix the permissions and prove it.

    it reads the error log, adjusts the directory block and filesystem permissions in the conversation's sandbox, restarts, and confirms the file is served.

    readbashedit

what to know before installing

the project needs a sandbox. apache is light enough for the small size beside an application. it binds the same default port as nginx, so a project that installs both needs one of them reconfigured before the second will start.

how to install Apache

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

  1. give the project a sandbox

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

the apache http server running in each conversation's own sandbox, with apache2ctl on the path and the config under its usual directories. agents edit virtual hosts, enable modules, restart the service, and call the site from the same box.

can an agent debug a rewrite rule properly?

yes, and this is where a live server earns its place. rewrite rules are almost impossible to verify by reading. an agent applies the rule, restarts, requests the url, and reads the log to see which rule actually fired.

is this for hosting a public site?

no. it runs in each conversation's own sandbox, one machine per conversation and nobody else's. we publish nothing from it and put no domain in front of it, and an agent's requests come from that same box, so this is about checking the server's behaviour rather than serving visitors.

does the config persist 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 an edited vhost is still in place 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.

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.