Platform · Architecture

Rapid change. Enterprise discipline.

Application creation can accelerate faster than the enterprise estate around it. Amoga contains that complexity in one architecture: a Runtime that interprets the application specification, AEGIS at every integration boundary, durable execution underneath and enterprise controls through the stack.

Explore the six planes Security architecture

Experience servicesBusiness work reaches people, devices and channels through one governed application model.

Web & PWAMobile surfacesDocuments & mediaBrand StudioDashboards

Amoga RuntimeInterprets application data, pages, rules, workflows, permissions and policy bindings.

Entity graphPage specificationRules & decisionsRole scopesApplication APIs

IAM · AEGIS · observabilityControls identity and every event crossing the boundary; makes execution inspectable and recoverable.

Identity & hierarchyEvent contractsPolicy & routingTrace & alertingRetry & recovery

Durable executionLong-running work retains history, timers, signals and recovery semantics across change.

TemporalEvent historyTask queuesTimers & signalsVersioned execution

Resilient substrateCompute, data, storage, networking and operations remain a managed enterprise foundation.

ComputePostgresObject storageNetwork policyMetrics · logs · traces

The technical model

Six planes. One dependency direction.

The Studio emits application meta. The Agentic Framework reads the graph derived from it. Runtime interprets it, AEGIS governs the events crossing its boundary, durable execution preserves work in flight and the substrate holds the enterprise foundation.

open each plane to trace one change

Digital Studio Build plane · emits meta Where a requirement becomes an approved specification, with the people who own the work in the room.

Step 01 Stated in the room requirement · specification

A business owner states the change in their own language. The studio parses it into a specification and holds it at a human approval gate. Nothing is generated until a named person signs.

requirement parsingstakeholder interviewsystem reverse-engineeringFRS draftinghuman approval gatedesign synthesisapplication generationtest-case generationUAT orchestrationCI/CD promotionlow-code / no-code editormeta diff & rollback

Agentic Framework Intelligence plane · reads the graph Agents read the same application graph the runtime executes, so what they touch is legible before it runs.

Step 02 Drafted against the graph meta diff · 4 workflows

Agents read the same application graph the runtime executes, and draft the revision as a meta diff. Before it runs, the impact is legible: four workflows, each named.

application graphcopilot iterationagent registryskills & toolsguardrailsRBAC-scoped data accessevaluation runstrace & decision loghuman-in-the-loopassistant · engagement · trigger · employee

Amoga Runtime Interprets application meta and runs the business on it. There is no generated codebase to inherit.

Step 03 Interpreted, not regenerated no generated codebase

The approved meta lands and the runtime reinterprets it. No repository is generated and no build ships: the application changes shape while every tenant stays on the same platform release.

Reads entity graph page + form spec rule set policy bindings

Identity & hierarchy

Enterprise hierarchyRBAC & ABAC scopesIAM · SSO · MFA · SCIMDelegation & deputiesImmutable audit trail

Workflow & decisions

BPMN 2.0 orchestrationCMMN case handlingDMN decision tablesSLA timers & escalationHuman task inbox

Channels

Web & PWAiOS & Android nativeGeo-location & geofenceCamera, media, e-signDashboards & KPI models

Engagement

Email & voiceChat & WhatsAppSocial inboxEmbeddable SDKBuild once, route anywhere

Brand Studio

Identity & design tokensVersioned logo & asset libraryLogin & shell experienceEmail, PDF & message artefactsVersioned publish & rollback

AEGIS Amoga Event-Driven Governance & Integration Suite Governs every event that crosses the boundary: schema, policy, rate, trace. It does not run the application.

Step 04 Governed at the boundary event · policy · trace

Every call the changed workflow makes leaves as an event: schema-checked, rate-limited, scoped to who may publish it, traced end to end. AEGIS governs the boundary; it does not run the application.

Event surface

Event bus & CDCPublish / subscribe routingREST · webhooksTransformation & mapping

Policy & control

Event schema contractsRate limits & throttlingContent filtering & redactionScoped produce / consume rights

Observability

Throughput, latency & errorsCorrelation-ID tracingThreshold alertingOne pane across integrations

Reliability

Durable event storeRetry with backoffReplay & recoveryFailed events held for review

Durable execution Temporal Temporal. Every workflow is replayable to the step, months-long processes included.

Step 05 Replayed, not restarted deterministic replay

Workflows already in flight keep their event history. Temporal replays them deterministically against the new version, so a process months into its life survives a change made this morning.

deterministic replayappend-only event historytimers & signalsretry policy with backoffidempotent activitiessaga compensationworker pools & task queuesversioned workflow codemonths-long processesexactly-once effects

Substrate Amoga PaaS (Azure/Oracle), your VPC, on-premise or hybrid: single- or multi-tenant, with isolation enforced below every plane.

Step 06 Nothing moved underneath isolation holds

The substrate did not change. Tenant isolation is enforced below every plane and the deployment target stays yours, which is why this cost hours rather than a release window.

Compute

Managed computeIsolated tenant workloadsBackground & batch runners

Network

WAF & firewall policyEgress control · VAPT testedTLS enforced end to end

Storage

Managed PostgresObject & block storageEncrypted at rest and in transit

Operations

Metrics, logs, tracesBackup & restoreManaged upgrades

Deployment Amoga PaaS (Azure/Oracle) Customer VPC On-premise Hybrid

Why the direction matters

An upper plane may read anything beneath it and nothing above it. That single constraint is what keeps a tenant's extension from becoming a fork, and what lets the runtime be upgraded under a live application.

What crosses a boundary

Only meta and events. The studio emits meta; the framework reads the graph derived from it; the runtime interprets and runs it; AEGIS governs the events that cross in and out. No plane shares a database schema with another.

Where tenancy sits

Isolation is enforced at the substrate and re-asserted by the runtime on every request: the enterprise hierarchy, the RBAC scope and the tenant key are resolved before a workflow starts. AEGIS carries the same scope onto every event that leaves.

← Platform overview Request enterprise demo Security architecture · Compliance evidence

The experience surface

One runtime. Every place enterprise work happens.

Channels, device context, documents, branded experiences and intelligence services are resolved against the same application definition. The application does not become a separate delivery project for every surface.

Channels

Web
PWA
Mobile
Email
Messaging
Voice

Device context

Location
Camera
Scan
Media
Offline-aware work

Documents

Versioning
OCR
Templates
Signatures
Controlled access

Experience

SSR
Caching
CDN delivery
White-labelling
Brand Studio

Intelligence

Dashboards
Operational measures
Pattern alerts
Copilot assistance
GRID context

Resolved onceIdentity · role · policy · application context · brandProjected by channel

AEGIS

Every boundary event carries its contract and its evidence.

The Amoga Event-Driven Governance and Integration Suite centralises how enterprise events are validated, governed, routed, observed and recovered. It protects the boundary; it does not become the application Runtime.

01 accepted Receive
event · API · webhook
02 checked Validate
identity · schema · scope
03 controlled Govern
policy · filter · rate
04 traced Route
transform · publish · consume
05 durable Recover
retry · replay · review

Correlation · EVT-7C921complete trace

10:12:06.142Order runtimepublished allocation-risk eventaccepted

10:12:06.167AEGIS policyvalidated schema, actor and consume rightschecked

10:12:06.204ERP connectortransformed and routed inventory requesttraced

10:12:06.418Recovery policyresponse attached to workflow historydurable

The agentic era

Shaped quickly, changed continuously, owned by a named person.

Enterprise digital work is no longer a delivery project that ends. It is a system that keeps moving. AI can accelerate drafting, specification and assembly. What it must never do is absorb accountability. At Amoga, agents propose and a person owns.

Change ledger · governed CR-1186

09:41:07 Collections agent proposed a strategy change: meta diff, 4 workflows touched Diff

09:44:12 318 test cases re-run against staging: all green Passed

09:52:30 A. Mehta · Head of Collections reviewed the behaviour and signed Signed

09:52:31 Promoted to production: rollback point pinned Live

Every change: a proposer · an approver · a rollback point

Speed

Shaped, not shipped once

First production release in days; a governed change in hours. The system keeps pace with the business it encodes, because revising meta is not a release project.

AI-native

Intelligence in the fabric

Agents are not a feature bolted to the side. They read the same application graph the runtime executes, so what they touch is legible before it runs.

Economics

Platform cost, not programme cost

One stack carries infrastructure, workflow, channels, integration and governance: the line items that usually arrive as five vendors and a systems integrator.

Assistance, with an owner

Agents draft; a person signs. Nothing is generated until a named owner approves the specification, in the language the business wrote it in.

Every change is reviewable. Revisions land as a meta diff with a test run, an approver and a rollback point: reviewed as behaviour, not as source.

Accountability is recorded, not implied. Each agent action carries its identity, RBAC scope, tools called and the policy it ran under, retained with the workflow history.

The application stays platform-owned. Extensions are meta. Every tenant inherits each platform release instead of diverging from it.

Code generation, without one

The codebase is yours on day one. A generated repository transfers the maintenance burden immediately, along with its dependencies, its drift and its blind spots.

Change re-enters engineering. Every business revision becomes a development ticket, because the model's output, not the approved specification, is the source of truth.

Review happens in the wrong language. Business owners sign off on requirements, then approve diffs they cannot read. Accountability quietly moves to whoever merged.

Upgrades become migrations. Each platform advance is a project against a frozen snapshot, which is how tech debt returns under a new name.

Bring your architecture questions.

We will trace one application change through the specification, Runtime, integration boundary, durable workflow, deployment context and evidence record.

See the platform in action Explore Agents & GRID