Skip to main content
Field notes / philosophy

The agent-first platform as a service

A platform as a service gave developers a database, a runtime, routing, identity and deploys so they could ship without running infrastructure. Plexara gives an agent the same layers as governed tools, plus what no developer platform had: your data, its definitions, your team’s knowledge and a record of every call. It is the first complete agent-first platform as a service, and every new frontier model is a direct upgrade to it.

11-minute readPhilosophy

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

LayerFor a developerOn Plexara, for an agent
DatabaseA managed database the developer provisions and migratesAn application database with transactions and enforced constraints, changed only by migrations the agent writes and a release applies after a rehearsal
RuntimeA place to run the code the developer deploysAutomations that run on demand, on a schedule, once per event, and once per request, each with tests that replay recorded runs
RoutingA URL for the app, and custom domainsAn 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
IdentityA login the developer wires into the appYour 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
DeploysA pipeline from a code repository to productionA release that pins every part, a private dev copy for sites, promote, and rollback, each recorded
Events and filesQueues and object storage as add-onsWebhooks, forms and mailboxes as event sources, and a library where every file is searchable and readable by the agent
OperationsLogs and metrics the developer readsA record of every run and every call, one alert when something breaks and one when it recovers, and a database health view
The left column is what a platform as a service has offered a developer since the late 2000s. The right column is what Plexara offers an agent today. Every row on the right is reached through a tool the agent can find, use and be refused by.

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

LayerWhat Plexara holdsWhat it changes
The company’s dataEvery database, API and GraphQL connection your team has set up, queryable and joinable, under one set of access rulesA new application starts with the business already attached
What the data meansA catalog of every dataset and column, a glossary, tags, domains, and lineage recorded from what runsThe agent builds against the right table with the right definition the first time
What the team knowsKnowledge pages, reviewed insights and memory that every later session readsA correction made once holds for every agent and every application afterwards
A record of everythingEvery tool call, every run and every reading of a sensitive field, with who or what caused itA person can verify what an agent did without having watched it
Instructions for the builderThe platform documents itself to the agent: how to write an automation, how to build an application, how to publish a siteA new model is productive in its first session
A developer platform hosts an application and knows nothing about the business it serves. These five layers are why an agent on Plexara builds something correct, and they were built first.

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

  1. One capability ships

    An event source for a mailbox

    Mail from approved senders becomes rows and searchable files.

  2. 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.

  3. 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.

  4. 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.

On a platform designed around one user, the agent, a new capability is one more tool under the same rules. It inherits the permissions, the audit and the agent that are already there.

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.

395

platform releases since January 2026

31

of them since mid-October 2026, about one a day

4

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