What a platform as a service was for
In the late 2000s a new kind of product changed who could ship software. A platform as a service took everything between a developer’s code and a running application (servers, a database, routing, identity, deploys, logs) and offered it as a service. NIST’s definition, published in 2011 and still the standard one, is precise about the bargain: the consumer deploys applications built with the languages, libraries, services and tools the provider supports, and does not manage the infrastructure underneath.
The effect was larger than convenience. A team of three could run what used to need an operations department. The platform’s constraints became the industry’s good habits, written down in the Twelve-Factor App: explicit dependencies, releases with their own identity, running code nobody edits in place. The platform decided what a well-formed application looked like, and developers who accepted the shape got the infrastructure for free.
Every one of those platforms shares an assumption so basic that nobody stated it: the builder is a person. A person reads the documentation, writes the code on a laptop, pushes it, watches the logs, and decides what to do next. The whole surface (the command line, the dashboard, the repository, the pipeline) is shaped to a human developer’s hands.
The builder changed
The most capable builders of software are now frontier models: Claude, ChatGPT, Gemini, and the ones that replace them. They write a working system from a description, test it, read the error, and fix it, at a pace no team matches. They are also a different kind of user. An agent does not browse a dashboard. It calls tools. It does not hold context between sessions unless the platform holds it. It will do exactly what its permissions allow, including the things nobody intended, and it does not know your business unless something tells it.
The industry’s response has been to attach an assistant to platforms built for people. The developer platform gets a chat panel that writes deploy configuration. The data platform gets a copilot that drafts queries. Each is useful and each inherits the shape of the product it was added to: the human surface is the real one, and the agent works through a narrow window onto it, inside one vendor’s product, with that vendor’s model.
Plexara was built the other way around. For two years the agent has been the user the platform is designed for. Every capability is a tool an agent can find by describing what it wants, use with a stated purpose, and be refused by when the access rules say no. The portal exists so people can see, review, approve and share what agents do. That decision, made at the start, is why Plexara is now the first complete agent-first platform as a service. The claim is specific, and the rest of this piece backs it layer by layer.
The same layers, as governed tools
Take the layers a platform as a service provides and ask what each one is when the builder is an agent.
The database is an application database: transactional, with constraints the database enforces, where the structure changes only through migrations the agent writes and a release applies after rehearsing them. The runtime is the automation: a script the agent writes and tests, which then runs without a model, on demand, on a schedule, once per event, or once per request. Routing is an address for every application, endpoint, form and site environment, with your own domains attached to the environments you choose. Identity is your identity provider, already standing in front of every page, with the signed-in person handed through to the application and to the row rules in its database. Deploys are releases: a pinned set of versions for an application, a private dev copy and a promote step for a site, and a rollback for both.
None of these required the agent to be given a cloud account, a credential or a command line. That is the part a developer platform cannot copy by adding an assistant. On Plexara the agent never holds the keys to infrastructure, because there is no infrastructure surface for it to hold. Deasil provisions, hosts, upgrades and monitors every deployment. What the agent has is a set of tools whose every call is checked against the access rules of the person it is working for, which is exactly where OWASP’s guidance says permission for an AI system belongs: enforced in the system being acted on.
The platform as a service, layer by layer
| Layer | For a developer | On Plexara, for an agent |
|---|---|---|
| Database | A managed database the developer provisions and migrates | An application database with transactions and enforced constraints, changed only by migrations the agent writes and a release applies after a rehearsal |
| Runtime | A place to run the code the developer deploys | Automations that run on demand, on a schedule, once per event, and once per request, each with tests that replay recorded runs |
| Routing | A URL for the app, and custom domains | An address for every application, every endpoint, every form and every site environment, with your own domains on the environments you choose, each private or public |
| Identity | A login the developer wires into the app | Your identity provider, already in front of every page that needs a sign-in, with the signed-in person handed to the application and to its database rules |
| Deploys | A pipeline from a code repository to production | A release that pins every part, a private dev copy for sites, promote, and rollback, each recorded |
| Events and files | Queues and object storage as add-ons | Webhooks, forms and mailboxes as event sources, and a library where every file is searchable and readable by the agent |
| Operations | Logs and metrics the developer reads | A record of every run and every call, one alert when something breaks and one when it recovers, and a database health view |
What a developer platform never had
A developer platform hosts an application and knows nothing about the business it serves. The developer carries that knowledge in their head: which table holds orders, what "active customer" means here, which system is the source of truth for price. An agent has no head to carry it in. This is the reason agent-built software so often works in a demonstration and fails in a company. The code is fine. It was built against the wrong table.
Plexara was a context platform before it was anything else, and that order matters. Before an agent on Plexara writes a line of an application, it can search one index that covers every connected database, API and GraphQL service, the catalog of what each dataset and column means, the glossary, the knowledge pages your team has written and reviewed, and the record of calls that were already run and what they were for. On our accuracy study, the same model answered 42.7 percent of business questions correctly on its own and 98.7 percent with that context. The difference between those two numbers is the difference between an application built on a guess and one built on your company’s actual definitions.
The record is the other half. Every tool call, every run of an automation, every release and every reading of a field marked sensitive is kept with who or what caused it. A person can verify what an agent did without having watched it do it. A company trusts a developer because it knows the developer. It trusts an agent because the record shows what the agent did, so the record has to be part of the platform.
What no developer platform had
| Layer | What Plexara holds | What it changes |
|---|---|---|
| The company’s data | Every database, API and GraphQL connection your team has set up, queryable and joinable, under one set of access rules | A new application starts with the business already attached |
| What the data means | A catalog of every dataset and column, a glossary, tags, domains, and lineage recorded from what runs | The agent builds against the right table with the right definition the first time |
| What the team knows | Knowledge pages, reviewed insights and memory that every later session reads | A correction made once holds for every agent and every application afterwards |
| A record of everything | Every tool call, every run and every reading of a sensitive field, with who or what caused it | A person can verify what an agent did without having watched it |
| Instructions for the builder | The platform documents itself to the agent: how to write an automation, how to build an application, how to publish a site | A new model is productive in its first session |
Why an agent-first platform compounds
A product assembled from separately built features grows by addition. Each feature has its own permissions, its own settings, its own log, and often its own assistant, and connecting any two of them is a project. A platform with one user and one set of rules grows by multiplication. When a capability ships on Plexara it is one more tool, and it meets everything already there on its first day.
Follow one example. A mailbox became an event source in October. Because automations already existed, an email could start a run. Because run records existed, that run had a history. Because the library existed, attachments became searchable files the agent can read. Because applications now exist, the mailbox is a part that appears in the diagram and the automation that reads it is pinned by the release. Because access rules existed before any of it, who may read those rows was already decided. Nobody built those connections. They follow from the design.
This is what the release count measures. Plexara has shipped 395 platform releases since January 2026, 31 of them since mid-October. That pace is only sustainable on a platform where a new capability does not need its own security model, its own audit and its own interface. The history of how the platform grew from a governed query layer to this is in from answering questions to running the work.
Why capabilities compound
One capability ships
An event source for a mailbox
Mail from approved senders becomes rows and searchable files.
It meets what exists
Every automation can start from it
The same run record, the same tests, the same approval in plain language, with nothing rebuilt.
It becomes a part
Every application can include it
The source appears in the diagram, and the automation that reads it is pinned by the release.
It is governed already
Every access rule applies
Who may read the rows, who may see a sensitive field, and what was done with them are answered by rules that existed before the capability did.
Every new frontier model is a direct upgrade
A platform built around one vendor’s assistant improves when that vendor improves its assistant. A platform built on open protocols improves whenever anyone advances the frontier. Plexara speaks the Model Context Protocol, so the model is the customer’s choice, and a new one connects the way the last one did. It finds the same tools, reads the same instructions the platform publishes about itself (how to write an automation, how to build an application, how to publish a site), and inherits the same access rules.
The consequence is concrete. The request that produced a report with last year’s model produces a working application with this year’s, on the same deployment, with the same governance, and with no migration project in between. Your data, your definitions, your knowledge pages, your automations and your applications stay exactly where they are while the builder gets better. Companies that put their context inside one vendor’s chat product will rebuild it for the next one. Companies on Plexara will change a setting in their AI client.
Deasil has built on open standards for 25 years and plans the next 25 the same way. That is a statement about engineering habit, and it is also the commercial logic of this platform: the value you accumulate is in the context and the systems, and those belong to you.
platform releases since January 2026
of them since mid-October 2026, about one a day
ways an automation starts: on demand, on a schedule, once per event, once per request
What this means for a company
The first wave of platforms let a small team ship what used to need a department. This one lets a department ship what used to need a software team. The marketing lead who needs a campaign site, the finance manager who needs a reconciliation system, the operations director who needs a supplier portal: each describes the outcome to an agent, reviews the diagram and the release, and has a working, governed system the same week. The economics of that shift are worked through in custom software stopped being expensive.
It also changes what you should ask of any platform that claims to be ready for AI. Ask who the user is. If the answer is a person with an assistant beside them, the agent is limited to one product and one model. If the answer is the agent, then the database, the runtime, the routing, the identity, the releases, the data, the meaning and the record all have to be reachable as tools under one set of rules. That is a long list. Plexara is the platform where every item on it has shipped.
Build on it
The Applications series
Seven lessons: what an application is, its database, the automations and endpoints that do the work, releases, rollback and the diagram, pages people open, and the shop end to end.
The Sites series
Seven lessons: your first site, dev and promote, private environments and public domains, your own domain, layouts and records, editing a live site, and moving an existing site.
Further Reading
The NIST Definition of Cloud Computing (SP 800-145)
Peter Mell and Timothy Grance, NIST · 2011
The standard definition of platform as a service: the consumer deploys applications built with the languages, libraries, services and tools the provider supports, and does not manage the infrastructure underneath.
The Twelve-Factor App
Adam Wiggins · 2011
The methodology written from the experience of running a developer platform: what an application must look like for a platform to build, release and run it.
LLM06:2025 Excessive Agency
OWASP · 2025
Why permissions for an AI system belong in the systems it acts on, enforced there, with human approval for high-impact actions.
