rAIlsApps Should Decide What Happens Next
Most AI applications still wait for a user to tell them what to do.
We think that is the wrong abstraction.
An agentic application should continuously observe its domain, determine what deserves attention, propose the next useful intervention, and then let a shared runtime decide how that work should be planned, governed, executed, verified, and learned from.
That is the direction behind the current rAIlsApps release.
From applications to operators
The reference applications are domain systems and capability providers around one shared AI Runtime Stack.
A support application can notice an escalation risk. Projects can detect an emerging milestone slip. Growth can identify a trend before saturation. Research can decide which question has the highest information value. A knowledge system can decide whether to teach, review, assess, or stop.
The important part is that they speak the same execution model.
One stack, clear responsibilities
The architecture deliberately keeps the taxonomy small.
Discovery Runtime is the scout. It observes world state, detects and correlates changes, ranks what deserves attention, and proposes work. It never executes the work itself.
Execution Planner designs the complete plan: representation, retrieval, reasoning depth, model, execution topology, verification, governance, budgets, and fallbacks. It is a planner.
Mission Runtime is the execution kernel. It turns the plan into governed, durable execution: state transitions, scheduling, approvals, retries, verification, compensation, replay, and audit.
Context Runtime decides what intelligence each individual step receives: which evidence to retrieve, how to represent it, which model and reasoning path to use, and whether the result meets the evidence threshold.
Capabilities do the work. Models, ReDevOps RAG, SQL, graphs, APIs, tools, agents, and humans all sit behind capability contracts.
Above them, Projects + Sidekick form the control plane. Projects holds durable desired and observed state; Sidekick is the conversational Mission Supervisor through which a person can set goals, inspect evidence, approve consequential work, and ask what needs attention.
Proactive intelligence is now a shared primitive
The release adds a deterministic Priority Engine and domain detector kernels built around a simple rule: confidence is not expected value.
A highly confident observation can still be a bad action.
Candidates are evaluated using probability, upside and downside, urgency, reversibility, execution cost, human-attention cost, risk, and information value. Doing nothing is always a candidate. When the evidence is weak, the system can abstain.
The current detector set includes:
- Growth Trend Intelligence for emerging topics before saturation;
- Projects Execution Risk Radar for emerging delivery risk;
- Research Information-Gain Planner for choosing what to investigate next;
- Knowledge Frontier for choosing whether to teach, review, assess, or stop;
- Support autonomy primitives for follow-up, escalation, lead scoring, knowledge improvement, and sentiment handoff.
These kernels have controlled synthetic backtests. Those tests validate the scoring logic and do not validate real-world predictive skill. Real-world lift requires live signals and live outcomes.
That distinction matters.
The apps can now learn from outcomes
A useful agentic system cannot stop at "the model chose an action."
The shared loop records a decision opportunity, the selected action and alternatives, and the eventual outcome. The learning layer can then adjust expected utility for future choices while remaining replayable and explainable.
Governance does not become a reward function.
A learned policy cannot decide that a risky action no longer needs approval simply because the action historically performed well. Outcome learning improves selection inside the permitted action space; authority, security, and approval remain hard boundaries.
Integrations without giving agents the keys
Agentic applications need access to real systems, but connecting an agent directly to SaaS credentials defeats much of the point of governed execution.
ReDevOps connectors therefore expose a common capability boundary. Credentials remain behind a CredentialBroker and missions receive opaque references without tokens.
External agents can enter through the Governed Agent Gateway using MCP or REST. They do not bypass the runtime: identity, permissions, risk, budgets, approvals, governed envelopes, egress policy and audit still apply.
This makes MCP an interoperability surface.
Discovery is becoming broader than any single app
One consequence of this architecture is that Discovery is broader than a feature such as "meeting intelligence."
A meeting is merely one changing evidence stream.
The same Discovery Runtime can observe email, chat, support cases, CRM changes, project events, documents, research sources, telemetry, repositories, or physical signals. It can determine what changed, whether it matters, what evidence is missing, and whether the current plan should change.
That gives the stack a useful general shape:
world
→ Discovery
→ world state + proposed work
→ planning
→ governed mission execution
→ verified outcome
→ learning
Sidekick becomes the operator surface over that loop.
Why the reference apps matter
The applications serve a purpose beyond fifteen unrelated AI products.
They are a proving ground for a stronger claim: domain applications can become specialized execution nodes while a common runtime owns planning, context, governance, cross-application execution, and learning.
A signal found in one domain can become a mission that uses capabilities from several others without a person copying context between applications or manually reconstructing permissions and state.
That is the practical shift from "AI inside apps" to an agentic application stack.
The UI still matters. But its job changes.
It becomes the place where humans set intent, inspect evidence, define policy, approve consequential decisions, and intervene when the system needs judgment.
Applications become operators. Sidekick becomes the supervisor. The runtime becomes the system that decides, governs, executes, verifies, and learns.
Availability note. The runtime, governance, integration/gateway mechanisms, Priority Engine decision logic, outcome-loop mechanism and persistence are implemented and tested. Detector-kernel results discussed above come from controlled synthetic validation and should not be represented as production predictive accuracy or commercial lift. Production efficacy remains dependent on real data providers and observed real-world outcomes. For the architecture, see Apps Architecture and the Platform Architecture.