Writing the system is the solved part
Ask a frontier model for an order system and it produces one: tables, a checkout, an API, a page that lists products. The models your team already uses (Claude, ChatGPT, Gemini, and the ones that replace them) do this in an afternoon, and each new generation does it faster and with fewer mistakes. The writing of software has become the cheap step.
What a company runs is something else. Software a business depends on has a known state: this version of the checkout, against this structure of the database, serving this page. It has a way to change that state on purpose, a way to know what changed, and a way to go back. Engineering teams spent twenty years building that discipline, and its center is one idea the Twelve-Factor App stated in 2011: building, releasing and running are separate stages, and nobody edits running code in place.
An agent with a code editor and a cloud account has none of that. It has a folder and a deploy command. The system it wrote works on the day it was written, and from that day its real state is whatever the last prompt left behind. Plexara closes this gap in the product. On Plexara the thing an agent builds is an application, and an application goes live one way: a release.
The unit of agent work is now the application
The work a company hands an agent has grown in three steps this year, and each step is a larger unit.
The first unit was the answer. An agent with governed access to the warehouse, the catalog and the knowledge your team has recorded answers a business question the way your analysts would. The second was the automation. Once the logic is settled, the agent writes it down as a script with tests, a person approves what it does in plain language, and it runs without a model in the loop: on demand, on a schedule, once per event, or once per request. Our October dispatch described a client’s Apache NiFi system of about 2,000 processors retired this way, one flow at a time.
The third unit is the application: a database of its own, the automations that read and write it, the forms and endpoints that people and partner systems use, the pages they open, and the sources of the events it reacts to, all named in one record. This is the unit a business actually thinks in. Nobody asks for a script. They ask for the returns desk, the supplier onboarding system, the store-opening tracker, the shop.
The unit of agent work, 2026
The answer
A question, answered from governed data
The agent reads the catalog, the definitions your team recorded and the warehouse, and returns a figure or a report. Nothing persists except the knowledge it leaves behind.
The automation
Settled work, run again without the model
The agent writes a script with tests, a person approves what it does, and it runs on demand, on a schedule, once per event, or once per request.
The application
A whole system, released as one thing
A database of its own, the automations around it, the forms and endpoints people and systems use, and the pages they open, pinned together by a release.
What an application is made of
An application on Plexara has five kinds of parts. Its database is a real transactional one: rows are committed or they are not, constraints are enforced by the database, and a checkout that would take stock below zero fails and takes its whole order back with it. It is built to be the system of record for an order system or a request tracker, and it is separate from the warehouse the agent queries for analysis. Its automations are the same governed scripts described in Automations, bound to that database. Its forms and endpoints are how people and other systems reach it, covered in Forms and Endpoints. Its pages are reports and dashboards saved to the portal, or browser pages served at an address of the application’s own. Its event sources are the places work arrives from.
Two properties of the database deserve attention, because they are what make an agent-built system trustworthy at the data layer. First, the application’s automations sign in to the database as a role created for that application alone, with no power to bypass the database’s own row rules. A rule such as "a customer sees only their own orders" is written once, in the database, and every path into the data is held to it, including paths the agent writes next month. Second, only the application’s own automations reach its tables. Another application that wants its data uses its endpoints, the way one team’s service calls another’s.
Every deployment includes a walkthrough of a shop an agent built with Plexara tools alone: a product catalog, stock, a checkout that records the order, its lines and the stock taken in one transaction, an order confirmation sent as an event after the order commits, nightly upkeep, and a storefront. Its checkout comes with it as a ready example. Your agent can read exactly how the shop was built, and build the next one for your business.
The release: what runs is what was approved
A release does two things in one step. It applies the database migrations that are waiting, and it pins every part at its newest saved version. From that moment the endpoint, the form, the schedule, the event runs and the pages execute and serve exactly those versions, and they keep doing so no matter what is saved afterwards.
This is the property that makes agent-speed development safe. The agent keeps working. It saves a new version of the checkout, drafts a migration that adds a column, rewrites the storefront. None of it is live. The application page in the portal shows each part with the version the release pins and whether a newer one is waiting, and it shows what the next release would change before anyone presses the button. A person reads that list, and the release makes the whole set live together. An application is edited and tested in pieces and shipped as a whole, so there is never a moment when the new checkout is running against the old table.
What one release holds
| Part of the application | What the release pins | What saving changes |
|---|---|---|
| Database structure | Every pending migration, applied in order | Nothing. A migration waits for the next release, and it was already run from zero on a throwaway copy of the database before it could be saved. |
| Automations | Each one at its newest saved version | Nothing live. The endpoint, the form, the schedule and the event runs keep executing the pinned version. |
| Pages and reports | Each asset at its newest version | Nothing live. The portal and the application address keep serving the pinned version. |
| A site environment | The release the environment before it serves, one step as a promotion would move it | Nothing live. The environment moves with the application, forward on a release and back on a rollback. |
| Event sources | Named as parts, so the diagram and the release know them | Not versioned. A source is an address that receives events, and the automation that reads it is what the release pins. |
The database changes only by migrations that were rehearsed
The riskiest thing a builder does to a running system is change the shape of its data. On Plexara that change has exactly one form: a migration, a numbered step with a way forward and a way back, written by the agent and applied only by a release.
Each migration is rehearsed twice before it reaches real data. When the agent saves it, Plexara builds a throwaway copy of the database, applies every migration from zero including the new one, and refuses to save a migration that fails there. The agent reads the plan before it applies anything, and a review flags the patterns that hurt a live table. Then, at release, the pending migrations run together inside one transaction that is rolled back. Only if that rehearsal passes are they applied for real. A migration that fails changes nothing.
The automations are tested the same way. Each test of the checkout runs against its own throwaway copy of the database, built from the migrations, with the rows the test itself writes. The test that proves an oversold order is refused runs against a real database with real constraints, every time the agent saves a change. An automation cannot alter a table at all: the database refuses it. The structure of the data and the code that uses it move forward together, by release, or not at all.
What gets refused
- 01
A migration that fails on the rehearsal
The pending migrations run together in one transaction that is rolled back. If any of them fails there, the release is refused before the real database is touched.
- 02
A part that no longer exists
A deleted automation or report, or a removed event source, refuses the release and is named in the refusal.
- 03
A part built against the wrong library version
When an automation loads one of the application’s shared libraries at a version other than the one the release pins, the release names the automation, the version it loads and the version to load.
- 04
A release decided against a stale picture
If another release moved the application after this one was prepared, this one fails and records nothing.
- 05
A statement that tries to change the structure
An automation cannot create, alter or drop a table. The database refuses it. The only way the structure changes is a migration that a release applies.
Rollback, and a diagram nobody had to draw
Every release is kept: the migration version it holds applied, the version of every part, what changed since the release before, who made it and why. Rollback restores an earlier release’s pins in one step and reverts the migrations applied since, when each of them has a way back. Martin Fowler’s description of blue-green deployment makes the point that the database is the hard part of going back, and that is why Plexara states the limit as a fact: when one migration since that release has no way back, none are reverted, and the rollback says which. A rollback is recorded as a release of its own, so the history shows the mistake and the recovery.
The second thing a release gives you is a picture. Each application has a diagram drawn from the parts themselves: which automation reads which table, which one writes it, which endpoint a page calls, which event starts which run, which report a schedule refreshes. Nobody draws it and it cannot go stale, because it is computed from the saved sources and settings. Drawing it runs nothing and calls nothing outside. It also reports findings, such as a table that the application’s automations read and no part writes. You can view it for the current release, for the newest saved versions, or as the difference between two releases, which turns "what did the agent change" into something a manager reads in a minute.
What a rollback restores
| Part | What rollback does | What it leaves alone |
|---|---|---|
| Automations, pages, reports | Return to the versions the earlier release pinned | The newer versions are kept and wait for the next release |
| Database structure | Migrations applied since that release are reverted, when every one of them has a way back | When one has none, none are reverted, and the rollback names it |
| The record | The rollback is written as a new release, with what it changed | The history never loses a release, including the one that was rolled back |
Who decides
OWASP’s guidance on excessive agency names the failure plainly: an AI system given more functionality, permission or autonomy than the task needs. Its recommended control for high-impact actions is human approval. An application release is that control placed at the right point.
The agent has wide freedom where freedom is cheap. It writes migrations, automations, forms and pages, runs the tests, reads the diagram, and prepares the release. Everyone signed in can read an application. Its owner and your admins edit it and add parts. Releasing and rolling back are admin actions, and a form reaches people who are not signed in only at a version an admin approved. The person who releases is deciding one thing, with the evidence in front of them: this exact set of versions, these migrations, this diagram, these findings.
This is a better arrangement than reviewing an agent’s work line by line, and a far better one than not reviewing it. A reviewer cannot keep pace with an agent at the level of code. A reviewer can keep pace at the level of a release, because a release is small enough to read and complete enough to trust.
What to do with this
Stop asking your agents for scripts and files. Ask for the system. Name the outcome, let the agent propose the tables, the automations and the pages, and have it show you the diagram and what the first release would contain before it releases anything. The discipline that used to require a platform team now comes with the request.
Move the tools people built in a hurry onto this footing. The spreadsheet with a macro, the form wired to a shared inbox, the script on someone’s laptop that reconciles two systems every Monday: each is an application waiting for a database, a release and an owner. See where agent-built tools should live for why the home matters, and automations you can leave running for how the parts stay healthy after launch.
And expect the gain to grow. Every part of this is something an agent can find, use and be held to, so a more capable model builds a larger application under the same rules. A release you can read, refuse and reverse is the reason you can hand the agent more.
Build one
Further Reading
The Twelve-Factor App: V. Build, release, run
Adam Wiggins · 2011
The rule that shaped a generation of deployment platforms: building, releasing and running are strictly separate stages, and running code is never edited in place.
BlueGreenDeployment
Martin Fowler · 2010
Keeping the previous version ready so that going back is a switch, and why database changes are the hard part of any rollback.
LLM06:2025 Excessive Agency
OWASP · 2025
The risk of an AI system acting with more functionality, permission or autonomy than the task needs, and the case for human approval of high-impact actions.
