The App Should Be an Execution Node, Not a Destination
Part of the agentic-apps thread. This one is about the interaction layer: what changes when the app stops being the place you go and becomes a capability the runtime calls.
There's a kind of software friction we've learned to treat as inevitable.
Suppose you want an AI workflow to work with your CRM. Before anything useful happens, you may have to create an integration, choose an API or app type, configure OAuth, select scopes, create credentials, map objects and fields, configure webhooks, decide which vendor-specific workflow to use, and then wire all of that into the application that actually needs the data.
None of those steps are the goal.
The goal was closer to:
"When a qualified lead comes in, check the account history, enrich what's missing, score the opportunity, update the CRM, and ask me before changing anything consequential."
Today, the human still has to translate that intent into the boundaries and integration model of several applications.
That exposes an architectural assumption we've lived with for decades:
The application is both the capability and the boundary you have to walk through to use it.
Agentic systems give us a reason to separate the two.
People have goals
Take that request again:
When a qualified lead comes in, check the account history, enrich what's missing, score the opportunity, update the CRM, and ask me before changing anything consequential.
Today that unfolds into something like: human → build an integration → pick an app type → OAuth → scopes → field mapping → webhooks → wire it into the workflow → then, finally, the work. Almost none of that is the goal. The goal was a scored, enriched opportunity landing in the CRM with a human check on anything consequential.
The CRM still matters: its records, its object model, its API, the actual opportunity. What changes is its role. Instead of being the system you configure an integration into, it becomes an execution node: something a runtime can call.
The runtime reads the intent, picks the capabilities that fit, builds each transaction, hands over exactly enough authority to complete it, runs it, checks the result, and keeps whatever receipt you'll need later. What reaches you is closer to:
This lead scores 82/100. The account has two open support tickets and a renewal in 30 days. Update the opportunity to Qualified and notify the owner?
One confirmation. No integration to stand up, no scopes to choose, no webhook to wire. Quite possibly no CRM screen at all.
The apps provide capabilities. The runtime owns the relationship.
That's the model we're building toward with rAIls. An agentic app should be able to expose what it's good at (reserve parking, move money, pull an account, retrieve a document, place an order, update a CRM record, run an analysis) without each app having to independently own the entire relationship with the person on the other end.
Those capabilities become nodes a planner can reach for. You state the goal once; the runtime works out which apps need to take part and drives them as one governed workflow.
This matters most the moment a task crosses app boundaries, and the everyday ones cross more than you'd think. Your bank reissues your card after a breach. The new number has to reach your utilities, your streaming services, your insurer, your gym, that SaaS tool you signed up for once: a dozen small relationships, each with its own login and its own form to fill out.
From your side, that shouldn't be a dozen apps and an afternoon. It should be one mission: update the card everywhere it's on file, inside the authority I grant, and tell me what you couldn't reach. The apps are implementation details of the execution graph. You should never have to open most of them.
Let the runtime own what's common across apps
If apps become execution nodes, the next question answers itself: what belongs in the app, and what belongs at the layer above it?
The domain capability belongs in the app. Most of the scaffolding around that capability does not. A shared runtime can carry the parts every app otherwise reinvents: intent and goal interpretation, capability discovery, context and evidence, planning, identity and delegated authority, permissions, preferences, payment authority, privacy boundaries, verification, approvals, observability, replay and governance.
This is the same argument that put ReDevOps on the map in the first place. Production AI applications keep rebuilding retrieval, context management, planning, model routing, execution, permissions, verification and observability, so we moved those concerns into reusable runtimes. Cross-app agentic workflows just extend that argument to the interaction layer: instead of rebuilding the relationship with the user inside every app, the runtime carries the context and authority across the mission.
Authority is a first-class runtime primitive
There's a world of difference between a runtime having the authority to do something and an agent holding your credentials. The second one is how you end up on the news.
The better abstraction is a scoped Authority Context that travels with the mission:
Identity → Authority → Preferences → Payment → Privacy → Mission
The runtime should be able to reason about who's asking, what a capability is allowed to see, what it's allowed to do, how much it can spend, which steps need an explicit yes, which credentials can be delegated, what personal information must never leave, and what receipts have to be kept. Each execution node gets only the slice it needs for its part, nothing more.
Which leads to one quietly powerful default:
Ask the person only for information or authority the runtime doesn't already have and can't safely derive.
That single rule would strip a remarkable amount of friction out of everyday software. It also reframes what "context" even means. Context is evidence, identity, permissions, preferences, state, authority, and the history you need to make a decision safely, along with text you paste into a prompt.
Discovery works out what's missing
This gives discovery a bigger job. It's about finding documents or deciding what deserves attention, and inside a live mission it decides what's missing before a goal can run at all.
Order my usual lunch.
Behind that, the runtime can already know most of it:
- identity: known
- food preferences: known
- payment authority: known
- delivery address: known
- which restaurant: unresolved
- anything over $25: needs a yes
So instead of sending you into an app, it asks the one thing it can't settle on its own, and then it's done. That's a genuinely different shape of interaction than "open the correct program and drive it yourself."
Crossing app boundaries makes governance more important
There's an obvious objection here: if a system can operate several apps on your behalf, a mistake can propagate across several apps too.
Right. That's exactly the point.
Taking away UI friction can't mean taking away control. If anything, cross-app execution raises the stakes on governance. A planner shouldn't hand an autonomous agent five sets of credentials and hope the sequence turns out fine. Execution nodes get scoped authority. Consequential actions pass through policy gates. Some things run automatically, some need review, some are never allowed.
A governed mission flows through something like:
Goal → Discovery → Execution Planner → Mission Runtime → Context Runtime → Capabilities → Governance & verification → Outcome
And the unit you govern is bigger than a single model call. Any one action can look perfectly reasonable while the trajectory (the shape of many actions together) is not. So the runtime has to watch the whole mission: which evidence drove which decision, which capabilities ran, what authority they held, what changed, and whether the behavior across the trajectory stayed inside policy. That's why trajectory and population governance sit where they do in the ReDevOps architecture.
Own the authority. Secrets can remain.
One more thing this is not: it isn't a pitch for one giant credential vault.
The runtime should own the authority model and can leave the underlying secrets where they are. Cards, payment instruments and identity data can stay tokenized and delegated, controlled by whoever already controls them. What the runtime needs to know is narrow:
This mission may spend up to $20 through this payment capability, for this purpose.
It doesn't need to hold the card to know that. The line between owning authority and possessing secrets is the whole game if this is ever going to be safe enough for real consumers and real enterprises.
Smarter silos, or composable nodes
This is also why a set of rAIlsApps can be worth more than the same apps as standalone AI products.
Build each one as another silo and bolt AI on, and you get smarter silos. Expose their capabilities to a common execution layer instead, and they become composable: one app's output is another app's evidence, a single mission spans several domains, and the planner picks capabilities by cost, latency, permissions and expected quality. The UI stops being the box the work has to happen inside and becomes a window onto the mission.
Which gives us a fairly compact definition:
Agentic apps are composable execution nodes. The runtime owns planning, context, authority, execution, verification and governance across them.
You should care whether the outcome you asked for happened correctly, economically, and inside the authority you granted, whichever app performed each step.
From app-centric to intent-centric
The app-centric model made sense when apps were how humans talked to computers: open the right program, learn its interface, translate your goal by hand into its operations. Agentic systems flip that. You state the goal; the system figures out how to run it.
Apps don't disappear in this picture: their logic, integrations, data and capabilities get more valuable. They just stop needing to be destinations. They become execution nodes in something larger, and a lot of the most irritating friction in modern software goes away because most of that onboarding never had to happen, and every onboarding flow getting a little nicer does not remove that friction.
The simplest version of the idea is the one worth keeping:
You should interact with the system to get something done and keep that relationship across every app it takes to get it done.
That's the direction we think cross-app agentic workflows should go. And it's one of the application models rAIls is being built to support.
rAIls, from ReDevOps, is a source-available Runtime Agentic Intelligence Stack for planning, context, execution and governance across production AI applications.
