Better together

Great ideas build together.

Omega is a product architecture for intent-first systems: one observable channel, typed intents, explicit flows, and agents that own side effects—so behavior stays inspectable from prototype to production.

Concept Code Production

Explore the model Where it integrates
Omega mascot

Mission & vision

Why Omega exists—and the future we are building for teams who think in systems: one language for product, design, and engineering.

Mission

To make intent-first, observable software the default for serious products: a single pipeline for the traffic that matters, with flows and agents that keep rules and side effects explicit—so quality scales with your team, not despite it.

Vision

Omega is the shared map from sketch to operations: the same concepts—channel, intents, flows, agents—in roadmaps, reviews, and telemetry—so every discipline aligns without re-learning the stack on every release.

The problem Omega solves

Modern development piles on boilerplate, competing architectures, and endless decisions. Omega brings one model—channel, intents, flows, agents—so teams move from complexity to clarity.

Diagram: left, problems in modern development—too much boilerplate, too many architectures, too many decisions, leading to complexity and frustration. Center, arrow toward Omega. Right, Omega simplifies everything—UI, Flow, and Agents connected to the Omega logo—with order and simplicity.

Omega at product level

Three ideas that stay true no matter which runtime you ship on: a single observable channel, explicit orchestration, and agents that keep the world honest.

The channel

One bus for what matters: every important signal flows as events you can subscribe to, trace, and reason about—no hidden callbacks scattered across layers.

See how it fits together

Intents & flows

The UI speaks in intents; flows own feature logic and routing. Orchestration stays explicit and testable instead of buried in widgets or controllers.

Concepts in depth

Agents

Side effects and integrations live in agents that listen on the channel—so IO stays at the edge and your product surface stays thin and predictable.

Read the model

Key features of Omega

Fast to adopt, less code to maintain, clearer architecture, and production-ready patterns—one hub that ties UI, flows, and agents together.

Key features of Omega: central Omega hub connected to five areas—Fast and simple, Reduces complexity, Less code, Production ready, and Clear architecture—with neon links on a dark cosmic background.

What Omega is

Omega is a reactive, intent-first architecture: all important traffic goes through one OmegaChannel as OmegaEvent values. The surface issues OmegaIntent commands; flows orchestrate business rules; agents run side effects and IO—so presentation stays thin and the pipeline stays observable.

How Omega works & UI communication

The UI issues intents; the channel carries events everyone can observe. Flows orchestrate feature logic and agents handle side effects—so the surface stays thin and every crossing between UI and engine stays explicit.

Diagram: how Omega connects the user interface with the channel, intents, events, flows, and agents—showing the communication path between UI and Omega runtime.

Where Omega integrates

Omega ships as libraries you embed in your delivery stack. The same conceptual model applies; each runtime adds its own tooling and wiring. Pick the track that matches how you build and ship.

Shared model

Channel, intents, flows, agents—keep UI thin and behavior inspectable.

Flutter

Inspector, VM Service, time-travel traces, and the omega CLI.

Angular

ESLint-before-serve, ng add, feature schematics, and router integration.

Guides by runtime

Vision and why

Data flow

Tooling depth differs by platform—for example, the mobile track emphasizes inspector and trace workflows today. See each site’s guides for the authoritative feature set and compatibility notes.

Shared mental model

The same names and responsibilities wherever Omega runs: channel, intents, flows, and agents—before you pick a runtime SDK.

OmegaChannel Broadcast bus: emit OmegaEvent or emitTyped; subscribe to events as reactive streams (your SDK maps to the platform’s stream type).
OmegaIntent Command with wire name, optional payload and namespace; created with fromName for typed enums.
OmegaFlow Feature unit: onIntent + onEvent. Some runtimes expose richer UI hooks (e.g. expression streams) or a slimmer emit surface—see the integration you ship.
OmegaAgent Reacts to channel traffic (behavior engines); not routed by the manager—wired at bootstrap. Lifecycle hooks differ by SDK (see Integrations).

Runtime comparison: reference implementations

When you integrate Omega on more than one stack, the public APIs stay aligned; behavior still differs where the frameworks diverge. Below is a concise map for implementers (omega_architecture · omega-angular).

Topic Flutter Angular
Channel implementation Broadcast Stream<OmegaEvent> RxJS Subject → Observable (multicasted; no replay)
OmegaFlow → UI expressions stream + lastExpression; optional OmegaFlowExpressionBuilder Flows emit via channel (protected emit); no first-class expression stream in the base class
Flow activity OmegaFlowState (idle, running, …); start / pause / switchTo — _runningFlows holds all flows currently running activate / deactivate / switchTo — activeFlowIds is the set that receives intents and channel events
handleIntent Optional registerIntentHandler first (can consumeIntent); then receiveIntent on each running flow onIntent on each active flow (insertion order)
OmegaAgent Abstract class + OmegaAgentBehaviorEngine, agent inbox/protocol, optional flow contract Concrete class: engines + onReaction; destroy() unsubscribes
Bootstrap OmegaRuntime.bootstrap — channel, OmegaFlowManager, OmegaAgentProtocol, OmegaNavigator, routes provideOmega({ createFlows, bootstrap?, createAgents? }) in Angular DI + APP_INITIALIZER
UI wiring OmegaScope, navigator key, inspector receivers/servers Inject OmegaChannel / OmegaFlowManager in components & services
Extra in package Time-travel recorder, offline intent queue, inspector & VM tooling, flow contracts (debug) ESLint-first builders, schematics, ng add wiring (see repo tooling)

Symbol map (quick reference)

Same symbols in both reference libraries where concepts align. See each package’s API docs on pub.dev / npm for signatures.

Concept Flutter (omega_architecture) Angular (omega-angular)
Event bus abstraction OmegaEventBus · OmegaChannel · OmegaChannelNamespace OmegaEventBus · OmegaChannel · OmegaChannelNamespace
Intent / event payload OmegaIntent, OmegaEvent, OmegaTypedEvent OmegaIntent, OmegaEvent, OmegaTypedEvent
IDs & wire names OmegaFlowId, OmegaAgentId, intent/event name enums OmegaFlowId, OmegaAgentId, intent/event name enums
Orchestration OmegaFlow, OmegaFlowManager OmegaFlow, OmegaFlowManager
Agents OmegaAgent, behaviors, protocol OmegaAgent, OmegaAgentBehaviorEngine
App entry (examples) OmegaRuntime, OmegaConfig, app omega_setup.dart provideOmega, consumer omega-setup.ts
Navigation OmegaNavigator, OmegaRoute, intent-driven routes Angular Router integration (guides)
Tooling (ecosystem) omega CLI, inspector, traces ESLint plugin, schematics, ng add omega-angular