AuraGo LogoAuraGo

Overview

Core entities: flows, retrievers, views, and content

How the main building blocks connect inside a campaign.

Overview13 min readUpdated 2026-09-20

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.

LevelEntityScopeBuilder location
1CampaignTop-level container for the full journeyCampaign editor
1Campaign StrategyTheory of change — aim, personas, brief, visual sequenceStrategic Hub
2StageOne self-contained interaction chapterStage canvas
3FlowLogic engine for a single stage (FSM)Flow Builder
3ViewOne interactive screen the user seesView Builder
3RetrieverContent selection pipelineRetriever editor
4PackageGrouped bundle of content itemsContent library
5ContentSingle 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.

SectionWhat it defines
FoundationsCampaign aim, value proposition, success signal
Persona modelingTwo to four audience archetypes with Jobs-to-be-Done, hindrances, and narrative
Creative briefTone, big idea, conversion logic
Product / serviceCapabilities mapped to behaviours you want to enable
Visual sequenceStep-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 typeRole
ViewRender an interactive view to the user
Data / RetrieverRun a retriever pipeline and capture output
LogicTransform or assign variables between steps
DecisionBranch on a condition (persona, choice, retriever rank)
AI ContentGenerate or adapt content at runtime from strategy context
Outbound SendTrigger 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.

NodeRole
LoadPull content items from a package (optionally filtered by content type)
FilterKeep items matching profile, persona, or field conditions
SortOrder items by a field or score
TopTake the first N items after sort
Content RankApply relevance or diversity ranking strategies
MergeCombine streams from multiple Load branches
BranchSplit the pipeline on conditions
YieldReturn 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

TypePurpose
profile_questionCapture profile data; options can carry behavioural traits
quiz_questionInteractive quiz-style question
magic_pageSingle-choice router — user pick determines next content path
selectorVisual grid picker — user chooses one option from a card set

Persuasion and conversion

TypePurpose
suggestionPersonalised recommendation or message
promotionOffer, deal, or campaign promotion
contrast_gridOld Way vs. New Way comparison (contrast principle)
social_wallTestimonials and trust signals (social proof)
benefit_calcInteractive value or savings calculator
epiphany_videoNarrative story-bridge video
squeeze_pageHigh-focus lead capture form
reminderUrgent nudge for deadline or action

Education, utility, and static

TypePurpose
learning_contentEducational material
newsNews article or update
auto_reportDynamically generated utility report
personalized_documentReport blocks routed by persona / driver tag
pageStatic 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.

TermDefinition
Interaction flowFull loop inside one stage: flow + views + retrievers + content, from entry to exit
Interaction stepOne view rendered at a point in the flow
User interactionThe moment a user acts on a step; input that advances the flow and updates their profile
Flow variableNamed value passed between flow steps (user choice, retriever output, computed flag)
Profile signalSemantic 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:

  1. Flow enters a View step and passes input parameters.
  2. View renders; the user reads and acts.
  3. User input returns as output parameters to the flow.
  4. Flow may update profile data, run a Decision, or call a Retriever.
  5. Retriever Loads from packages, filters/ranks content, Yields a result.
  6. 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 / settingDescription
Name, descriptionIdentity in the builder and reports
Stages (ordered list)Execution chapters; each links one flow
Orchestration modeLinear stage sequence or dynamic AI routing
DeploymentSmart links, web tags, activation status
Strategic Hub sectionsFoundations through Visual Sequence

Stage

Field / settingDescription
Linked flowThe one FSM that runs this stage
Linked views, retrievers, packagesAssets scoped or attached to this stage
Exit criteriaWhen the stage is considered complete
Audience targetingOptional filters on who enters
Order / routing rulesPosition in the campaign journey

Flow

Field / settingDescription
States and transitionsFSM graph in Flow Builder
Step typesView, Data, Logic, Decision, AI Content, Outbound Send
VariablesNames and scopes for data passed between steps
Entry / exit statesWhere the stage starts and how it ends
Linked view / retriever IDsAssets invoked at each step

View

Field / settingDescription
Adaptive Card JSONLayout and components
ThemeOrg theme from Theme Studio
Input parametersData bound from flow variables or retriever output
Output parametersUser-click and form data returned to the flow
Viewer modeSingle-item vs. collection presentation

Retriever

Field / settingDescription
Pipeline nodesLoad → Filter → Sort → Top → Yield (and variants)
Source packagePackage ID on Load nodes
Content type filterRestrict Load to one type (e.g. only promotion)
Rank / sort rulesHow items are ordered before Yield
Yield mappingShape of data returned to the flow variable

Package

Field / settingDescription
Title, descriptionHuman-readable label
Contents listMember content item IDs
ScopeCampaign-wide or stage-specific

Content

Field / settingDescription
Content typeOne of the types listed above
Title, aliasIdentity; alias used for cross-references in flows and views
Type-specific fieldsDefined by the content type schema (headline, options, media, traits, etc.)
StatusDraft, active, archived

Terminology

TermDefinition
CampaignTop-level behaviour change journey; holds strategy, stages, assets, and deployment
Campaign StrategyStrategic Hub definition — aim, personas, brief, product mapping, visual sequence
StageSelf-contained interaction chapter with one flow and linked assets
FlowStage-scoped FSM; wires views, retrievers, logic, and exit
ViewInteractive Adaptive Card screen with input/output parameters
RetrieverPipeline that loads, filters, ranks, and yields content from packages
PackageNamed bundle of content items for retrievers and flows
ContentSingle typed asset (promotion, profile question, magic page, etc.)
Content typeSchema and behaviour class for a content item
Interaction flowComplete in-stage loop from entry to exit
Interaction stepOne rendered view within that loop
User interactionOne user action on a step that advances the flow
Flow variableNamed data slot passed between flow steps
Profile signalSemantic interpretation of a user choice stored in the HDC graph
Strategic HubBuilder area for Campaign Strategy sections
Flow BuilderVisual editor for stage flows
View BuilderAdaptive Card designer for interactive views
HDCHyperdimensional profiling graph that captures behavioural signals

  • 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.