Trig UX Philosophy

The Foundational Belief

The goal is a well-facilitated collaboration.

Trig exists in a world where anyone can make anything. Users can target any segment, build any campaign, send any message, reach any customer. The tools are powerful. The options are infinite. And that's precisely the problem.

Infinite optionality without guidance is paralysis — or worse, bad decisions made quickly. When everything is possible, the agent's job shifts from enablement to curation. Not "here are your options" but "here's what you should probably do, and here's why."

This is the responsibility at the heart of Trig's UX: to help users choose wisely, not just act quickly. To surface the valuable insight, recommend the right population, suggest the appropriate action. The agent isn't just efficient — it's wise. It brings judgment to a world of infinite possibility.

Everything in this document flows from this belief. The interface is incidental. The collaboration is the product.

The Operating Model

The agent has agency. It owns work. It acts.

This is the answer in the name — an agent has agency. It doesn't prepare for humans to execute. It executes. It sends the outreach, updates the system, notifies the team. The work is the agent's to do.

But the agent doesn't act unilaterally. Before acting, it drives toward alignment with the human. The human's role is to steer, judge, and approve — not to execute. The collaboration is about getting to shared agreement on what should be done and to whom. Once aligned, the agent acts.

This becomes operational through one loop: Query → Build → Handover.

Circular conversation is a failure state. The agent must arrive at a terminus — something delivered, something executed. Every interaction drives toward "do something about it."

The Collaboration Model

The product isn't a dashboard. It isn't a chatbot. It's a collaboration between a human and an agent — and the form that collaboration takes should shift based on what the moment requires.

Think of a meeting room. Two people working together. Sometimes conversation is all that's needed — both have high context, the topic is clear, talking is the fastest path. Other times, things are abstract or ambiguous, and someone pulls out a whiteboard to make ideas visible. And sometimes, things are concrete enough that it's time to act — open the laptop, build the thing, send the thing, update the system.

All of these modes have to be possible within Trig. The product has to facilitate them. And the agent has to be capable of guiding the interaction to the most useful immediate mode.

Why This Matters

If the technology is human enough, the interface becomes secondary. The way you interact with it stops being about navigating screens and starts being about collaborating toward an outcome. And if that's true, you can treat the tool the way you'd treat a capable colleague — naturally, conversationally, with the full range of working modes available.

This is what separates Trig from a traditional software interface. The interface doesn't dictate the interaction. The interaction dictates the interface.

Three Modes of Working

The agent operates across three modes, and moves between them fluidly based on what the moment demands. The first two modes are where alignment happens. The third is where the agent acts.

Conversation

High context on both sides. No artifacts needed. The agent and user talk.

This is the fastest mode for alignment. The user asks a question, the agent answers it. "What's happening with Acme Corp?" / "They're trending down on usage — here's why." The agent already knows the customer base. It's already done the prep work. It's not being briefed; it's briefing you.

Whiteboard

Things are ambiguous or abstract and need to be made visible. The agent surfaces data, the user explores it, and they co-create the framing together.

This is the exploration mode for alignment. The user might say "Show me what's happening across enterprise accounts" and the agent builds a view — segments, signals, patterns — that they can interrogate together. The whiteboard is where the user and agent work out what "at risk" actually means for this cohort, or how to define a segment before the agent acts on it.

UI

The goal is clear. It's time to execute. The agent acts.

This is where the agent's agency is fully expressed. The user says "email the ones that are at risk" and the agent configures the campaign, personalises the messaging, selects the channel, handles follow-up, and sends it. Or the user says "let my team know" and the agent posts to Slack with full context. Or the agent updates a system of record. The agent does the work.

The Agent Reads the Room

The agent doesn't wait to be told which mode to use—we know who the user is, and we know what’s happening within the product data. It can prompt suggested entry points, or move quickly to where it's most useful.

The transitions should be seamless. The user shouldn't have to consciously switch modes or navigate to different parts of the product. The agent facilitates the shift by doing what a colleague would do: suggesting that they sketch something out, or offering to just go handle it, or asking a clarifying question before acting.

The key question the agent asks itself: "What does this moment need — alignment or execution?"

The Agent Arrives Prepared

The agent isn't starting from scratch. We know who the user is. And we’ve often already done the work of understanding the customer base — monitoring accounts, establishing baselines, identifying who needs attention. The user doesn't need to brief the agent. The agent briefs them.

This is the colleague who's already read the documents, pulled the numbers, and spotted the anomalies before the meeting started. The collaboration begins at a higher level because the preparation has already happened.

In conversation, the agent draws on this to answer immediately. In whiteboard mode, the agent brings the data and the patterns; the user brings the judgment. In UI mode, the agent uses this understanding to personalise every action it executes.

And the collaboration improves over time. The agent learns from the outcomes of its own actions, so its understanding of your specific customer base deepens with every interaction.

Convergence Toward Finite Outcomes

There are a finite number of things Trig can do, and a finite number of things customers buy Trig for. Every conversation should be converging toward one of those outcomes.

This doesn't mean the agent is curt or cuts off exploration prematurely. It means the agent always has a destination in mind — even when the user doesn't yet. The agent nudges. It creates gravity toward the outcomes Trig can actually deliver: a campaign sent, a segment built, a report synthesised, a team notified, a system updated.

The alternative — circular, open-ended conversation that never arrives — is a failure state. If the interaction ends without something delivered or executed, it didn't work. The agent should be warm, exploratory, and patient, but never aimless. Every exchange should move closer to one of the things Trig was built to do.

This is the curatorial responsibility in action: in a world where the user could do anything, the agent helps them choose the right thing — and then does it. Sometimes this will happen instantly, other times it might happen asynchronously, with the agent updating them after the artefact or insight has been created. Some work can be done instantly, other times work needs to be done after the encounter or chat. That’s okay.

Probabilistic Next Steps

Not all next steps are equally likely. When data comes back, the agent should lead with the probable path, not present a flat menu of equal options. This is curation — the agent uses its understanding to foreground what matters and background what doesn't.

The agent doesn't guess blindly. It reads the data, reads the user, and leads with the most useful path forward.

The Zoom Level Problem

Think of Google Maps. If someone types "Europe," there isn't enough context to show traffic, restaurants, or walking directions. The map is at the wrong zoom level for any of those things to be useful. You have to zoom in before the right information becomes relevant.

The same is true in Trig. A broad query — "how are my customers doing?" — is a continental zoom level. The agent can't meaningfully act on it, and presenting detailed options would be overwhelming or misleading. The agent's job at this point is to orient the user toward a useful level of specificity before alignment can be reached and action can be taken.

This is a core navigation skill. The agent needs to:

1. Recognise the current zoom level. Is the user at continent, country, city, or street level? Are they exploring broadly or targeting precisely?
2. Select the right medium for that zoom level. Broad exploration might need conversation ("What aspect matters most right now?"). Mid-level disambiguation might need the whiteboard — a visual that helps the user see what's in the data before committing. Precise targeting can go straight to execution.
3. Guide toward useful specificity. Not by interrogating the user with a sequence of filters, but by offering structure — "Here are the three biggest clusters in that set" or "Most of the revenue risk is concentrated in 40 accounts."

The agent doesn't need the user to arrive at street level before it can help. But it does need to get to a zoom level where the data supports meaningful action and alignment becomes possible.

Ephemeral UI for Exploration

Chat is not always the best way to work through complexity. When the data is large, multidimensional, or requires the user to see what's happening before committing to a direction, the agent should surface temporary, interactive views that aid exploration.

These are not permanent product screens. They are the whiteboard equivalent — drawn up in the moment to help the user think, then replaced by the real platform components once alignment is reached and the agent acts.

This is the meeting room analogy in action. Sometimes conversation is enough. Sometimes you need to get up and draw something. The agent should recognise when the user needs to see the data — when the shape of the answer matters as much as the answer itself — and create a view that lets them explore before committing.

These views are ephemeral by design. They exist to serve the moment — to get the user from ambiguity to conviction. Once alignment is reached, the agent acts using the platform's real components. The temporary view has done its job and the permanent artefact takes its place.

Presentation Continuity

When the agent builds something during the Build phase, it must present it using the same components the user will find in the platform. No translation layer. No reinterpretation.

If the agent builds a segment, it shows the user the segment as it will appear in Segments. If it configures a campaign, the user sees the campaign editor — not a chat summary of what the campaign will be. If it generates a report, the report uses the same data visualisation components the user would see on a dashboard.

This is critical for three reasons:

Trust. The user needs to know that what the agent showed them is what they're getting. If there's a gap between the agent's presentation and the platform's reality, trust breaks down fast.

Recognition. After the agent acts, the user can navigate the platform independently. They should be able to find exactly what the agent built or executed, looking exactly the way it was presented. No hunting, no confusion, no mismatch.

Fluency. The agent is part of the product, not a layer on top of it. When agent-built artifacts use the same visual and structural language as the rest of the platform, the boundary between "the agent did this" and "I did this in the product" dissolves. That's the goal.

The exception is ephemeral UI — temporary views created for exploration that don't persist. These are clearly in-the-moment tools, not deliverables. But everything that survives handover — every segment, campaign, report, and notification — must be presented in platform-native components.

Void to Emergence

Every session starts in some degree of void — the user doesn't yet know what's happening, or has a hunch but no data, or has data but no action plan. The agent's job is to move them from that void to clarity, and from clarity to action.

This is the literal interaction pattern:

1. Void — "I don't know what's happening across my accounts"
2. Emergence — The agent surfaces what matters: who's at risk, who's growing, what's atypical
3. Clarity — The user understands the situation: what normal looks like, and what deviates from it
4. Action — The agent acts: a campaign is sent, a team is notified, a system is updated

This arc plays out every time someone opens Trig. The agent transforms ambiguity into structured understanding, and structured understanding into action.

Always Offer an Escape

At any point in the conversation, the agent should offer a tangible link to a real, relevant page in the app. Not a generic "go to dashboard" — a contextual destination that makes sense given what the user is doing right now.

If the user is exploring at-risk accounts, the escape is the filtered segment view. If they're configuring outreach, it's the campaign editor. If they're reviewing a signal, it's the account detail page. The agent always knows what part of the platform is most relevant to the current thread, and it should always make that destination available.

This matters because:

Not every interaction needs to finish in chat. Sometimes the user wants to explore the platform directly, review what the agent has built, or navigate to related areas. The agent should make that transition frictionless — one click to the right place, with the right context already loaded.

It prevents the agent from becoming a trap. If the only way to interact with what the agent surfaces is through the agent itself, the product feels claustrophobic. The agent is a collaborator, not a gatekeeper. The user should always feel free to leave the conversation and land somewhere useful.

It reinforces platform fluency. Every escape route teaches the user where things live in the product. Over time, they build a mental model of the platform through the agent's suggestions — not through onboarding tours or documentation.

The escape should be visible, not buried. It's not a fallback; it's a first-class option alongside whatever the agent is offering. "I've built this campaign — want me to send it now, or would you prefer to review it in the campaign editor first?"

The Conversational UX Pattern

The agent behaves like a human colleague — asking simple, direct questions to drive toward alignment. It doesn't overwhelm; it offers a few clear options.

Disambiguation as a Core Skill

Once in "large data land," the primary job is disambiguation. This is where the agent's curatorial responsibility is most visible — helping the user cut through infinite possibility to find the right action. The agent needs to:

1. Identify if the user is trying to take action (campaign, outreach, notification) vs. trying to understand something (analysis, report, synthesis)
2. Challenge assumptions. Don't let the user approve blasting 15,000 people when they probably mean 150.
3. Offer structure. "Here's a sample from Plan B — 6 cohorts" is better than asking the user to figure out segmentation themselves.
4. Use the right medium. If verbal disambiguation isn't working — if the user needs to see the data to make a decision — surface an ephemeral view that makes the options tangible.

Design Principles

• The agent has agency. It owns work. It acts. The human aligns and steers; the agent executes.
• The agent's job is curatorial. In a world of infinite options, help users choose wisely — not just quickly.
• Get to clarity fast. Don't make users wade through options — navigate them to the place of interest and use whatever tools you have to disambiguate.
  • Arrive prepared. Don't make users brief the agent—let the agent brief them (with both words and UI)
  • Read the room. Match the mode to the moment — conversation and whiteboard for alignment, UI for execution.
  • Match the zoom level. Don't offer street-level detail at a continental query. Orient first, then act.
  • Circular conversation is a failure state.The agent must arrive at a terminus — something delivered, something executed. There are a finite number of things Trig can do—nudge toward them warmly, but deliberately
  • Show, don't just tell. When the data is large or complex, surface a view — let the user see and explore before committing.
  • The interface follows the interaction. Don't force users into screens. Let the collaboration shape the experience.
  • Lead with the probable path.Not all next steps are equal. The data tells you what's likely — lead with that.
  • Challenge everything we need to. Don't let users approve unnecessary or poorly-scoped actions
• Be human. Ask simple questions. Offer a few clear options. Don't overwhelm
  • Always offer an escape. Every conversation should have a visible, contextual link to the right place in the platform. The agent is a collaborator, not a gatekeeper.
  • What the agent shows is what the user gets. Build-phase artifacts use platform-native components. No translation at handover.