Administering a web interface end to end

The heaviest of the demonstration cases, and the one that says the most about what an agent can actually carry: driving an administration interface the same way a person would, over several steps, behind a login.

Not editing configuration files by hand for steps the interface exists to handle.

Setting up a self-hosted dashboard

An operator installing a monitoring or web-analytics dashboard behind a reverse proxy: creating a dashboard, wiring a data source, setting an alert rule. All of it through the panel, driven by the agent.

This includes targets sitting behind a network-level HTTP Basic challenge — the kind a reverse proxy adds in front of everything:

{"http_credentials": true, "url": "https://target.local/admin", "actions": [...]}

Confirmed against a real proxy-protected interface rather than a synthetic fixture: the credentials resolved from the encrypted directory answered the challenge on the first attempt. The scenario still names no secret — http_credentials tells Diwall to read them from that directory, scoped to that origin.

Running a ticketing platform

Across several sessions: event setup, ticket categories, a custom domain, and the check-in tooling used on the day. Real configuration work, through the same web interface a human administrator would use.

It was not a friction-free success story, and that is what makes it worth reporting.

Session handling had to be worked out. A dropdown behaved unexpectedly. A permission prompt blocked an unattended step and had to be handled explicitly.

None of those were Diwall problems. They were ordinary web-automation obstacles — the same ones any person automating that interface would meet. A demonstration that hides them teaches nothing about what the work actually costs.

Each of them now has a recipe:

• The session does not survive between two calls →
• It clicked, but not on the element you meant →
• The form reports success and never submits →

What makes this case work

One call for anything stateful. Log in, act, confirm — in a single invocation. Splitting it across calls loses the DOM state, silently.

An assertion at the top. If the page is not the one expected, stop before typing anything anywhere.

The encrypted directory for every credential. The scenario stays committable because it names keys, never values.

Signals read, not just the verdict. After each step: where am I really, what did the server say, did the session hold.

Where it stops

Operations lasting minutes fit badly — you see the end, not the middle, and a timeout does not mean failure. Bulk mutations are better done through an API if one exists. And nothing here can be undone: Diwall executes the list you wrote.

Why no scenario ships for this. A dashboard layout, data source names, a ticketing configuration — all specific to one operator’s infrastructure. Inventing a synthetic equivalent would demonstrate nothing that the runnable local case does not already cover.

Limits →