The agent can publish now
For most of the last two years an agent’s output stayed inside the building. It answered a question, wrote a report, ran an automation against data the company already governed. A mistake was an internal mistake.
That boundary is gone. An agent on Plexara builds a website and serves it on your own domain: a marketing site, product documentation, an annual report, a client portal, an intranet. The same agent maintains it. Someone says the pricing page is out of date, and the agent edits the page. The capability is real and it is the right one to have, because the alternative is the queue every marketing and communications team knows: a ticket, an agency, two weeks, for a paragraph.
It also means the most consequential question about an agent has changed. It used to be what the agent can read. It is now what the agent can put in front of the public, and under whose decision. A company that lets an agent write directly to its public website has delegated its voice to a process nobody watched. A company that forbids agents from touching the website has kept the queue. Plexara takes neither position. It draws a line through the product, and the line has a name everyone in software already knows.
The line is dev
Every site on Plexara has an environment called dev. It is the working copy, it is always private, and it is the only environment that accepts a change. Every publish and every edit in place lands there, from agents and from people alike. The agent’s freedom inside dev is complete: it can rebuild the whole site ten times in an hour.
Every other environment, the ones other people use, moves in exactly two ways: promote and roll back. Promote points an environment at the release the environment before it serves, one step at a time, so a release reaches production only after it has been served everywhere before it. Roll back points it at a release it served before. An attempt to publish or edit one of those environments directly is refused, and the refusal names dev and promote so the agent knows what to do instead. The rule has no exception for rank. An administrator cannot edit production directly either.
This is worth dwelling on, because it is where the design departs from how most teams run websites. In a typical content system, production is the thing you edit, and preview is a courtesy. Here production is not editable by anyone. It can only be told which reviewed release to serve.
One site, three environments
| Environment | How it changes | Who can open it | What it is for |
|---|---|---|---|
| dev | Every publish, every edit in place, from agents and people alike | Always private: the people who manage the site, and anyone it is shared with | The working copy. Nothing people rely on is served from it. |
| stage | Promote and roll back, and nothing else | Private: the client approving the work, a department, or everyone inside the organization | Review by the people who have to say yes |
| prod | Promote and roll back, and nothing else, with approval first when the environment requires it | Private at every address Plexara gives it; public at your own domain once the owner makes that domain public, or kept private for an intranet | What your visitors, clients or staff use |
A person promotes the exact release that was reviewed
A release of a site is a complete, fixed set of files with a number. The Twelve-Factor App made this the rule for applications in 2011: a release is immutable, any change is a new release, and going back means returning to an earlier one. Plexara applies it to everything an agent publishes.
The consequence is that review means something. A person opens dev at its own address, signed in, and looks at release 12. The portal shows which files changed, which were added and which were removed since the release people are using now. When that person promotes, production is pointed at release 12: the same files, byte for byte. Nothing is rebuilt, regenerated or re-prompted between the review and the visitor’s screen. A model is not asked to do it again and trusted to produce the same thing.
That closes the failure agent workflows are most prone to, the gap between what was approved and what ran. It also makes promotion cheap. Promote and roll back copy no files and take effect at once, so the cost of a careful process is one click, and the cost of a mistake is one more.
From an agent’s edit to a visitor’s screen
Change
The agent edits dev
A new page, a corrected price, a rebuilt layout. Each change is a new release of dev, and only what changed is stored.
Review
A person opens dev
At its own address, signed in. The portal shows the files changed, added and removed since the release people are using.
Promote
The exact release moves
Promote points the next environment at the release the one before it serves, one step at a time. No file is copied or rebuilt, so what was approved is what is served.
Approve
An approver agrees, where required
On an environment that requires approval, the request waits in Approvals with the changed files in view.
Serve
People use it
The change shows at once. Roll back returns the environment to a release it served before and still keeps, in one step.
Every environment is private until a domain is made public
Who can open an environment is set per environment, and whether an address answers anyone is set per address. Every address Plexara gives a site sits behind your organization’s sign-in, checked on every request, and opens for the people who manage the site and whoever the environment is shared with. Only a domain you add can be public, and only when the site’s owner or an admin makes that one domain public.
This makes one site do several jobs. A redesign lives on a private stage environment shared with the one client who has to approve it, and that client signs in through your identity provider and sees that environment and nothing else. A share can name a person or a whole role, and a role share follows membership: someone who joins the role can open the environment on their next visit, and someone who leaves cannot. One setting opens a private environment to everyone inside the organization, which is an intranet. Outside people get view access only. They can never be given the ability to manage a site, which is described further in sharing with clients without giving them an AI and on Client Access.
Every environment has an address of its own, and a site has a main address that serves whichever environment the owner chooses. Your own domains attach to an environment, and Deasil routes them. A domain is added private, so the team can read the site at its real name before anyone else can. dev can never have a domain, because a domain is how the public arrives and dev is where unfinished work lives.
Going public is the owner’s decision
Two actions change what people reach: making a domain public, and moving the main address onto an environment. Both belong to the site’s owner and your admins. Someone who manages the site without owning it cannot do either, and neither can an agent working for them.
When the owner chooses Make public, the portal asks for the domain’s name to be typed and says the site’s other addresses keep asking for a sign-in. On an environment that requires approval, the request waits in Approvals, and the approval holds only for the access it was asked against: a domain made private and later made public again needs approval again. A domain on an environment that requires approval can be removed only by an admin.
OWASP’s guidance on excessive agency recommends two things for high-impact actions: a human approves them, and the permission is enforced in the downstream system instead of left to the model’s judgment. This is that guidance implemented where it counts. The agent is never asked to decide whether something should be public. The platform does not let it.
Who decides what
| Action | An agent | Someone who manages the site | The owner or an admin |
|---|---|---|---|
| Publish and edit dev | Yes, when the person it works for manages this site | Yes | Yes |
| Promote and roll back | Yes, through Approvals where the environment requires it | Yes | Yes |
| Share a private environment | Yes, view access only | Yes | Yes |
| Add a person who manages the site | No | No | Yes, and only internal people |
| Make a domain public | No | No | Yes, after typing the domain’s name to confirm |
| Move the main address | No | No | Yes |
Why a line beats a review step
Most proposals for governing agents add a review step to a process that otherwise stays the same: the agent prepares a change, a person approves it, the change is applied. The weakness is in the last three words. Something has to apply the change, and if that something is the agent, the approval was advisory.
A line is stronger than a step because it is structural. There is no code path by which an edit reaches production, so no prompt, no clever instruction and no tired reviewer can create one. The agent’s speed is contained in a place where speed costs nothing, and the only thing that crosses is a fixed object a person chose.
It is also kinder to the people involved. Reviewers are not asked to read diffs of generated HTML at the pace an agent writes them. They are asked to look at a working site at a private address and say yes. That is a judgment a marketing lead, a compliance officer or a client can make, which is the point: the person who owns the message approves the message.
The pattern, stated generally
The same five rules govern any surface an agent builds that outsiders will see, and they are how Plexara sites work today. An application’s pages follow them through their application’s releases, described in software an agent builds needs a release: saving changes nothing live, and a release or a rollback moves every page and endpoint together. A site environment can itself be a part of an application, in which case it is released and rolled back with it.
If you are evaluating any system that lets AI publish, ask it these five questions. Where do changes land? What exactly moves when something is approved? Who decides exposure, and is that enforced by the system or requested of the model? How do you go back? Does the rule bind administrators too?
The pattern for any agent-built public surface
- 01
One place accepts changes
Agents and people change a working copy that nobody outside the team can open. Everything else is read-only to them.
- 02
What moves is the thing that was reviewed
Promotion points an environment at an existing release. Nothing is regenerated between review and serving, so a reviewer’s yes covers exactly what goes live.
- 03
Exposure is set per address, by a person
Every address asks for a sign-in until the owner makes one domain public, confirmed by typing its name, with approval where you require it. The rest stay private.
- 04
Going back is one step and is recorded
Every environment keeps the releases it served. Roll back returns to one of them, and the history shows who moved what and when.
- 05
The same rule binds everyone
An administrator cannot edit prod directly either. A rule with no exception for senior people is a rule an agent cannot talk its way around.
What to do with this
Give the website to the people whose words are on it. The team that owns the pricing page should be able to say "the Enterprise tier now includes single sign-on, fix the page and the comparison table" and review the result in dev that afternoon. The owner promotes. Nobody opens a ticket.
Bring existing sites over instead of rebuilding them. An agent copies a site you already run into a release, keeping its addresses and turning its redirects into the site’s redirect rules, and from then on it is maintained by request. Larger sites keep their content as records (products, posts, locations, people) and Plexara generates the pages, lists and category indexes from layouts, so a new location is one record and a promote.
Then hold the line. The value of dev and promote comes from having no exceptions, and the platform gives you none to grant. Your agents get the full speed of the frontier inside dev, and your people keep every decision about what the world sees.
Build one
Further Reading
LLM06:2025 Excessive Agency
OWASP · 2025
Excessive functionality, permissions and autonomy as the root causes of damaging agent actions, with human approval and downstream enforcement as the mitigations.
The Twelve-Factor App: V. Build, release, run
Adam Wiggins · 2011
A release is immutable and has its own identity; any change creates a new release, and rollback is a return to an earlier one.
BlueGreenDeployment
Martin Fowler · 2010
Switching which complete version is live, so that release and rollback are both a change of pointer.
