← redevops.io
Apps · the app layer over the runtime · redevops.io

Apps architecture

Domain systems over one runtime.
The companion to the Platform Architecture page: how the reference applications sit on the canonical AI Runtime Stack rather than beside it.

The system at a glance

16rAIlsApps
6domain agents
7functional blocks
11open-source cores
1Mission Runtime
1Context Runtime
The 6 domain agents (orchestrators)
Each drives a set of apps as missions. Consequential actions are approval-gated.
Revenue Agent
Turns buying signals into pilots and recovers revenue leakage.
Outreach EngineTwenty CRM
Agentic CRMERPNext
Market Radar↔ Intelligence
Growth Assistant↔ Content
Intelligence Agent
Read-only discovery: what's working, what's changing, where spend pays.
Growth EngineUmami
Control TowerMetabase
Market Radarchangedetection
Content Agent
Organic presence and founder content, on a cadence.
Social AutopilotPostiz
Growth Assistantserved LLM
Security & Compliance
Triage, audit-ready evidence, KYC and data-subject requests.
Edge SentinelCrowdSec
ComplianceOpenSCAP
PrivacyDSAR / GDPR
Finance Agent
Continuous financial discovery: billing, close, reconciliation.
BillingLago
BooksERPNext
Customer Success
Discovery-driven customer missions: answer, onboard, nurture.
SupportChatwoot
GuideContext Runtime
LifecycleListmonk
All work flows through the shared runtime plane (no direct app-to-app calls)
The shared runtime plane

Every agent compiles its work into a governed mission. The runtime binds apps, holds each step at a gate, verifies outcomes and can replay the whole mission.

Mission RuntimeSingle orchestration plane for all actions
Plan
  • simulate
  • and validate
Schedule
  • approval
  • gates
Execute
  • run on
  • app core
Verify
  • independent
  • read-back
Record
  • immutable
  • audit log
Context RuntimeSingle door for retrieval
Authorize
  • RBAC-scoped
  • classify and filter
Retrieve
  • tenant / app isolation
  • permitted egress
Ground
  • immutable snapshots
  • and receipts
Guardrails

policy enforcement, safety checks

Observability

logs, traces, metrics, anomaly detection

Identity & Access

users, service accounts, tenant and app scopes

Data & Artifact Store

missions, evidence, receipts, model outputs

Event Bus

asynchronous events, replay and recovery

Registry

apps, cores, capabilities, versions and approvals

Open-source cores (per app runtime)
Each app governs one core runtime. Examples:
Lagobilling
ERPNextbooks / CRM
Twenty CRMoutreach
Umamianalytics
MetabaseBI / dashboards
Postizsocial publishing
CrowdSecsecurity
OpenSCAPcompliance
Chatwootsupport
Listmonkemail
changedetectionwatches
… and others
External services
Ad platformse.g. Google, Meta — approval-gated
Signal & market datacompetitor pages, data vendors — Market Radar
Reached only through governed connectors; credentials stay behind the broker.
Example cross-app mission flows
Each arrow is one node's verified outcome handed to the next. Gate = human sign-off.
1 · Customer onboarding
Billingsubscription
Supportwelcome
Booksrevenue
ComplianceKYC
gate
Guideongoing
2 · Invoice recovery
Control Toweroverdue
Billingdunning
gate
Bookspayment
Supportfollow-up
3 · Lead to pilot
Market Radarsignal
Outreachcampaign
gate
Agentic CRMpilot
Lifecyclenurture
4 · Content loop
Growth Engineattribution
Growth Assistantstrategy
Social Autopilotpublish
gate
Guidemeasure
one colour per domain agent   gate = human sign-off on a consequential step ↔ a shared app two agents both drive

rAIlsApps are not separate orchestration stacks. They are domain systems and capability providers that share the canonical platform lifecycle. A signal found in one application can become one governed mission spanning capabilities from several domains — one identity chain, one evidence trail, one approval model, one replayable history.

The shared lifecycle

Every app flows through the same path. Discovery proposes, the Execution Planner designs, Mission Runtime governs execution, and Context Runtime supplies intelligence to each step — the app contributes domain observations, capabilities, actions and outcomes.

WorldState / StateDelta
the app's observed domain — CRM activity, project events, documents, telemetry, conversations…
↓
Discovery Runtime
observe · detect · correlate · rank · propose  —  what deserves attention?
↓
DiscoveryProposal
a proposal, never an execution
↓
Execution Planner
representation · retrieval · reasoning · model · topology · verification
↓
Mission Runtime
gate · execute · compensate · verify · replay · audit
↓
Context Runtime
retrieve · assemble · route · reason · verify
↓
Capability plane
models · RAG · SQL · graphs · APIs · tools · agents · humans
↓
Outcome → Learning + WorldState update
every outcome updates policy and the world model
Projects + Sidekick are the control plane above this flow. Projects owns durable desired and observed state, connected capabilities, policies, approvals, mission history and learning state. Sidekick is the conversational Mission Supervisor: it accepts goals, explains plans and evidence, surfaces discoveries, requests approvals and coordinates work — but every mutation still runs through Mission Runtime.

Proactive intelligence

Each domain can contribute deterministic detectors or decision producers without inventing another runtime. Their common loop is:

observe
  → detect opportunity / risk / anomaly / gap
  → generate intervention candidates
  → estimate utility, urgency, information value, cost and risk
  → act | request approval | defer | abstain
  → observe outcome
  → learn

The shared Priority Engine ranks these candidates with two invariants: confidence is not expected value, and doing nothing is always a valid candidate. what_needs_me(...) can therefore aggregate attention across domains without turning every signal into a notification or an action.

Current kernels cover growth trend intelligence, project execution risk, research information gain, knowledge-frontier selection, and support-autonomy primitives. CRM next-best-action, outreach timing, analytics anomaly-to-action and wealth assumption-drift feed the closed outcome loop. The newest additions are a Revenue Intelligence family that resolves REVENUE_LEAKAGE and QUOTE_FEASIBILITY across the CRM, ERP, support and billing systems of record — read-only sensors, business entities resolved before it reasons across them, every recovery action parked on approval (how it works) — and a Content & Growth Intelligence loop that pursues search-visibility and lead-generation goals the same governed way, learning per site from what you approve. note Controlled synthetic tests validate their logic; production predictive skill requires live signals and outcomes.

From signals to governed autonomy

Closing the loop honestly is a substrate problem, not only a scoring one. Observations are bi-temporal: each carries when it was true in the world (valid_at), when it became legitimately knowable (known_at) and when it was ingested — so any evaluation can reconstruct exactly what was knowable at a past decision and never train on the future. Every decision the runtime makes is written first as an immutable, event-sourced intervention record (the chosen action, the alternatives, the evidence, the policy version); correlating an outcome later appends a link rather than mutating the record. Attribution is multi-factor — temporal proximity, causal-link strength and competing interventions all weigh in, so elapsed time alone never decides whether an action caused an outcome. Postgres holds this operational truth.

On that substrate the system earns autonomy in stages — each one independently validatable before the next is enabled:

A0 · Historical replay built
reconstruct what was knowable at each past decision and compare the runtime's choice with the expert's later action — behind a hard leakage gate. Surfaces broken projections and bad ranking in hours; claims agreement, not causality.
↓
Shadow built
the runtime recommends but does not act; the human acts; the outcome is observed. A human action is simply an intervention by a human actor, so agreement, override and “abstention vindicated” all fall out of one log — the human is a capability, not ground truth.
↓
Governed Assist built
only the safest read-tier actions auto-execute, and only where a capability is registered; anything above that cap — or anything that fails — routes to a human. A learned policy is adopted only through an explicit promotion gate (collect → evaluate on a held-out time split → promote), never per-outcome.
↓
Governed Autonomy next
widen the auto-execute envelope tier by tier as evidence accrues — each step an explicit, reversible policy decision, never a default.

honesty These stages are implemented and validated on synthetic environments and a local operational database. Learning changes which action is favoured, never whether governance applies — a consequential action stays gated no matter how attractive its learned utility. Real-world predictive skill still requires a live deployment with real signals and outcomes.

Integrations and external agents

Domain systems reach external services through the Integration Plane and governed connectors. Credentials remain behind the CredentialBroker; plans, models and Sidekick receive references rather than credential material.

External agents use the Governed Agent Gateway (MCP first, plus REST). Gateway calls follow the same identity → permissions → risk → budget → approval → governed execution → egress → audit path as native work. MCP therefore exposes governed capabilities; it does not create a privileged bypass.

Runtime-native: target architecture and current status

design target Each agentic app is meant to be runtime-native: its decisions, actions and model calls go through the core runtimes rather than living in app code. An App Kit manifest declares the app's decision producers, its governed capabilities, a read-back verifier for each side-effecting capability, and its outcome kinds, and the registry rejects manifests that break the contract. The target invariants are: decide through the decision spine, act only as a governed Mission node, execute only on approval, verify every side effect, learn only from real outcomes, keep private data inside the trust boundary, and report only measured numbers.

enforced today Consequential actions on the operator boundary are approval-gated, with signed approval tokens; approved actions execute. Conformance tests run in CI for the manifest and approval invariants. in progress Wiring the decision spine (the Priority Engine is implemented and tested, but not yet driven by live app state), real read-back verification across apps (live today for a few capabilities: books close, social publish, compliance ticket), and governed model routing across apps. Most apps' learning feeds are labelled sample/demo.

design target The business domains are suites: compositions over the canonical app operators. A suite's capability surface is the union of the apps it composes, and the target is that composing an app that is not runtime-native fails closed. Today the six domain agents also run as their own services in the published compose stack.

design target Model calls are meant to be routed by a governed model router under an explicit privacy mode: business and customer data stays inside your trust boundary, external frontier models are used only for coding and infrastructure work over non-business context, and unclassified evidence is treated as confidential, failing closed rather than leaking. Rolling this routing out across every app is in progress.

portability The agentic-apps stack deploys from the published instructions on a Docker host (on-prem or a cloud VM), with a bring-your-own-model path; the cloud-specific deployment skills are described on the deploy page.

Why this matters

A discovery in one application can become one governed mission spanning capabilities from several domains while preserving one identity chain, evidence trail, approval model and replayable execution history. The human no longer has to become the integration layer between applications.

The UI remains important, but increasingly as a control surface: set intent, inspect evidence, approve consequential actions, change policy and intervene when judgment is required.

Companion to the Platform Architecture specification. For the release narrative, see the blog; for the plain-English tour, In plain English.

redevops.io · Apps Architecture