Overview
AuraGo campaigns are built from a small set of named entities — strategy, stages, flows, views, retrievers, packages, and typed content — each with a clear job in the journey from design to live interaction.
This page is a lookup reference for those entities. If you want the narrative walkthrough first, read Understanding campaigns, stages, and interactions. Use this page when you need a quick definition, want to see how entities nest, or are deciding where a new asset belongs.
How to read this page
Each entity below has a what it is, where it lives, and what connects to it. The terminology table at the end collects one-line definitions for every term on a single screen.
Entity hierarchy
AuraGo organises a campaign top-down. Strategy informs stages; each stage runs one flow; the flow renders views and calls retrievers; retrievers read from packages; packages hold typed content.
| Level | Entity | Scope | Builder location |
|---|---|---|---|
| 1 | Campaign | Top-level container for the full journey | Campaign editor |
| 1 | Campaign Strategy | Theory of change — aim, personas, brief, visual sequence | Strategic Hub |
| 2 | Stage | One self-contained interaction chapter | Stage canvas |
| 3 | Flow | Logic engine for a single stage (FSM) | Flow Builder |
| 3 | View | One interactive screen the user sees | View Builder |
| 3 | Retriever | Content selection pipeline | Retriever editor |
| 4 | Package | Grouped bundle of content items | Content library |
| 5 | Content | Single typed asset (copy, question, offer, etc.) | Content editor |
Mnemonic: campaign → stage → flow → view / retriever → package → content.
Campaign
A campaign is the top-level container for a behaviour change journey. It holds:
- Campaign metadata — name, aim, deployment settings, smart links, and orchestration between stages.
- Campaign Strategy — the behavioural design encoded in the Strategic Hub (see below).
- Stages — ordered (or dynamically routed) chapters of the live experience.
- Shared assets — views, retrievers, packages, and content that stages reference. Assets can be scoped to one stage or reused across the campaign.
At runtime, a user enters the campaign through a smart link or embedded widget, lands in a stage, and moves through that stage's flow until exit criteria are met — then optionally transitions to the next stage.
Campaign Strategy
Campaign Strategy is not a separate database object — it is the strategic face of the same campaign, defined in the Strategic Hub before (and alongside) implementation work.
| Section | What it defines |
|---|---|
| Foundations | Campaign aim, value proposition, success signal |
| Persona modeling | Two to four audience archetypes with Jobs-to-be-Done, hindrances, and narrative |
| Creative brief | Tone, big idea, conversion logic |
| Product / service | Capabilities mapped to behaviours you want to enable |
| Visual sequence | Step-by-step campaign shape — profiling, persuasion, conversion blocks — with a live alignment score |
The Visual Sequence should map to your stage list. When strategy and implementation diverge, the alignment score surfaces drift before launch.
Stage
A stage is a self-contained interaction chapter inside a campaign — one complete experience a user can enter, move through, and exit.
Each stage owns:
- One flow — the finite-state machine that drives logic for this chapter.
- Linked views — screens the flow renders at each step.
- Linked retrievers — pipelines the flow calls to select content.
- Linked packages — content bundles available to those retrievers and flows.
- Exit criteria — conditions that mark the stage complete (e.g. user submitted a profile, reached a conversion view).
- Optional audience targeting — restrict or prioritise who enters this stage.
Rule of thumb: one stage, one interaction flow. When the journey needs a new goal, channel, or strategic beat, add a stage — do not stretch a single flow across unrelated phases.
Cross-stage movement (linear sequencing, bridge messages, dynamic AI routing) is campaign orchestration, not flow logic.
Flow
A flow is a finite-state machine (FSM) scoped to a single stage. It decides what happens next after each user action or data step.
What a flow does
- Loads and initialises the stage (entry state, variables, step index).
- Renders views at View steps.
- Calls retrievers at Data steps and stores their output in flow variables.
- Branches at Decision and Logic steps based on profile signals, persona tags, or retriever results.
- Ends the stage when exit criteria are met.
Common flow step types
| Step type | Role |
|---|---|
| View | Render an interactive view to the user |
| Data / Retriever | Run a retriever pipeline and capture output |
| Logic | Transform or assign variables between steps |
| Decision | Branch on a condition (persona, choice, retriever rank) |
| AI Content | Generate or adapt content at runtime from strategy context |
| Outbound Send | Trigger a message or handoff outside the current view stream |
Flows are built in the Flow Builder and validated before activation. Variables pass data between steps — user input from a view, retriever output, persona tags — so later steps can branch or personalise.
View
A view (stored as an interactive view) is a designed screen your audience actually sees — built with Adaptive Cards in the View Builder.
What a view holds
- Card layout — text, images, inputs, buttons, and containers styled with org themes.
- Input parameters — data the flow passes into the view (e.g. a ranked list from a retriever, a persona label, dynamic copy slots).
- Output parameters — data the view sends back to the flow when the user acts (button click, form submit, selection). Wired via the user-click protocol into flow variables and HDC profile slots.
Views are reusable across stages and campaigns. A flow references a view by ID at a View step; the runtime engine renders it inside the Web SDK widget or channel adapter.
Common view patterns: profiling step, persuasion screen, offer block, multistep form, magic-page router.
Retriever
A retriever is a content-selection pipeline. Flows call retrievers when they need the right content for this user at this moment — not a fixed asset every time.
Pipeline model
Retrievers are node graphs. Data flows in from packages and profile context, is shaped by intermediate steps, and exits through a Yield node back to the flow.
| Node | Role |
|---|---|
| Load | Pull content items from a package (optionally filtered by content type) |
| Filter | Keep items matching profile, persona, or field conditions |
| Sort | Order items by a field or score |
| Top | Take the first N items after sort |
| Content Rank | Apply relevance or diversity ranking strategies |
| Merge | Combine streams from multiple Load branches |
| Branch | Split the pipeline on conditions |
| Yield | Return the final selection to the calling flow step |
A single retriever can serve multiple flow steps or stages. Connect retrievers from the stage canvas or wire them in a flow Data step.
Package
A package is a named bundle of content items — the unit retrievers Load from and flows reference when they need a collection rather than one fixed item.
Packages group related assets for a purpose: "profiling questions for scrollers", "persona A persuasion blocks", "Q1 promotions". Contents inside a package share a campaign or stage scope but can mix content types (e.g. profile questions alongside suggestions).
Use packages to:
- Feed retriever Load nodes with a bounded content set.
- Reuse the same content pool across multiple retrievers or stages.
- Version and manage content as a set rather than item by item.
Content
Content is a single typed asset — one promotion, one profile question, one magic page, and so on. Each content record has a content type that defines its schema, editor fields, and runtime behaviour.
Content is authored in the content editor (JSON forms, AI assist, or CSV import where supported). Contents live inside packages; retrievers and views consume them at runtime — directly (view bound to one content item) or indirectly (retriever yields the best match from a package).
Content types
Every content item has exactly one content type. The type determines which fields you edit and how the runtime interprets the asset.
Profiling and routing
| Type | Purpose |
|---|---|
profile_question | Capture profile data; options can carry behavioural traits |
quiz_question | Interactive quiz-style question |
magic_page | Single-choice router — user pick determines next content path |
selector | Visual grid picker — user chooses one option from a card set |
Persuasion and conversion
| Type | Purpose |
|---|---|
suggestion | Personalised recommendation or message |
promotion | Offer, deal, or campaign promotion |
contrast_grid | Old Way vs. New Way comparison (contrast principle) |
social_wall | Testimonials and trust signals (social proof) |
benefit_calc | Interactive value or savings calculator |
epiphany_video | Narrative story-bridge video |
squeeze_page | High-focus lead capture form |
reminder | Urgent nudge for deadline or action |
Education, utility, and static
| Type | Purpose |
|---|---|
learning_content | Educational material |
news | News article or update |
auto_report | Dynamically generated utility report |
personalized_document | Report blocks routed by persona / driver tag |
page | Static authority content |
Content type vs. view layout
Content types describe what the asset is. Views describe how it is presented — layout, theme, input/output wiring. One view can render different content types via parameters; retrievers select which content, views decide how it appears.
Interaction terms
These terms describe runtime behaviour — useful when reading logs, Profile Explorer, or flow debug output.
| Term | Definition |
|---|---|
| Interaction flow | Full loop inside one stage: flow + views + retrievers + content, from entry to exit |
| Interaction step | One view rendered at a point in the flow |
| User interaction | The moment a user acts on a step; input that advances the flow and updates their profile |
| Flow variable | Named value passed between flow steps (user choice, retriever output, computed flag) |
| Profile signal | Semantic tag derived from a user choice — motivation, hesitation, JTBD hint — stored in the HDC graph |
Runtime cycle
When a user is live inside a stage, entities connect in a repeating loop:
- Flow enters a View step and passes input parameters.
- View renders; the user reads and acts.
- User input returns as output parameters to the flow.
- Flow may update profile data, run a Decision, or call a Retriever.
- Retriever Loads from packages, filters/ranks content, Yields a result.
- Flow stores retriever output in variables and moves to the next View step — or exits the stage.
Profile signals accumulate across steps within a stage and across stages within the campaign. The Campaign Strategy you defined gives those signals meaning in Profile Explorer.
Fields and settings
Quick reference for the main configurable attributes per entity.
Campaign
| Field / setting | Description |
|---|---|
| Name, description | Identity in the builder and reports |
| Stages (ordered list) | Execution chapters; each links one flow |
| Orchestration mode | Linear stage sequence or dynamic AI routing |
| Deployment | Smart links, web tags, activation status |
| Strategic Hub sections | Foundations through Visual Sequence |
Stage
| Field / setting | Description |
|---|---|
| Linked flow | The one FSM that runs this stage |
| Linked views, retrievers, packages | Assets scoped or attached to this stage |
| Exit criteria | When the stage is considered complete |
| Audience targeting | Optional filters on who enters |
| Order / routing rules | Position in the campaign journey |
Flow
| Field / setting | Description |
|---|---|
| States and transitions | FSM graph in Flow Builder |
| Step types | View, Data, Logic, Decision, AI Content, Outbound Send |
| Variables | Names and scopes for data passed between steps |
| Entry / exit states | Where the stage starts and how it ends |
| Linked view / retriever IDs | Assets invoked at each step |
View
| Field / setting | Description |
|---|---|
| Adaptive Card JSON | Layout and components |
| Theme | Org theme from Theme Studio |
| Input parameters | Data bound from flow variables or retriever output |
| Output parameters | User-click and form data returned to the flow |
| Viewer mode | Single-item vs. collection presentation |
Retriever
| Field / setting | Description |
|---|---|
| Pipeline nodes | Load → Filter → Sort → Top → Yield (and variants) |
| Source package | Package ID on Load nodes |
| Content type filter | Restrict Load to one type (e.g. only promotion) |
| Rank / sort rules | How items are ordered before Yield |
| Yield mapping | Shape of data returned to the flow variable |
Package
| Field / setting | Description |
|---|---|
| Title, description | Human-readable label |
| Contents list | Member content item IDs |
| Scope | Campaign-wide or stage-specific |
Content
| Field / setting | Description |
|---|---|
| Content type | One of the types listed above |
| Title, alias | Identity; alias used for cross-references in flows and views |
| Type-specific fields | Defined by the content type schema (headline, options, media, traits, etc.) |
| Status | Draft, active, archived |
Terminology
| Term | Definition |
|---|---|
| Campaign | Top-level behaviour change journey; holds strategy, stages, assets, and deployment |
| Campaign Strategy | Strategic Hub definition — aim, personas, brief, product mapping, visual sequence |
| Stage | Self-contained interaction chapter with one flow and linked assets |
| Flow | Stage-scoped FSM; wires views, retrievers, logic, and exit |
| View | Interactive Adaptive Card screen with input/output parameters |
| Retriever | Pipeline that loads, filters, ranks, and yields content from packages |
| Package | Named bundle of content items for retrievers and flows |
| Content | Single typed asset (promotion, profile question, magic page, etc.) |
| Content type | Schema and behaviour class for a content item |
| Interaction flow | Complete in-stage loop from entry to exit |
| Interaction step | One rendered view within that loop |
| User interaction | One user action on a step that advances the flow |
| Flow variable | Named data slot passed between flow steps |
| Profile signal | Semantic interpretation of a user choice stored in the HDC graph |
| Strategic Hub | Builder area for Campaign Strategy sections |
| Flow Builder | Visual editor for stage flows |
| View Builder | Adaptive Card designer for interactive views |
| HDC | Hyperdimensional profiling graph that captures behavioural signals |
Related concepts
- Understanding campaigns, stages, and interactions — narrative introduction to the same hierarchy
- AuraGo platform at a glance — platform layers and Strategic Hub in context
- Builder vs runtime explained — what you design vs. what executes live
- User engagement flow —
/docs/user-engagement-flow/understanding-engagement-flows(deeper flow FSM detail) - Content selection with retrievers —
/docs/retrievers/understanding-retrievers(retriever pipelines) - Visual interactions —
/docs/visual-interactions/understanding-interactive-views(views and Adaptive Cards) - Creating and packaging contents —
/docs/contents-and-packages/content-types-overview(full content type reference)
Was this article helpful?
Feedback is saved when Postgres is configured, and logged in local preview mode.