← Back to conduet.ai
Sign inStart free

Runtime Modes

Conduet runs your agent in one of two runtime modes. The mode is decided by the project's framework and shapes everything about how a conversation flows — what the model sees on each turn, where state lives, how branching works, and what kinds of products fit naturally.

Pick the right mode for your product

Agentic mode

framework: "agentic"

One LLM, one persona, one tool-calling loop per user turn. You configure phases — each with its own instructions, tool allowlist, and exit condition — and the model decides what to do within those guardrails.

Best for:

  • Conversational products where users can say anything at any point
  • Customer-support agents that need to switch between topics
  • Sales / quoting / triage flows where the user is mostly free-typing
  • Anything where "the model figures it out" is acceptable behaviour

Conversation-flow mode

framework: "conversation-flow"

A directed graph of typed steps you assemble on a canvas. Each step has a job — ask a question, branch on a value, call an API, run an LLM — and the runtime walks the graph turn by turn.

Best for:

  • Scripted dialogs that follow a fixed sequence (KYC, multi-form capture)
  • Flows where every path needs to be visible and auditable
  • Multi-LLM patterns (extractor + responder, parallel branches)
  • Anywhere you need step types beyond "model + tools" — code, parallelism, post-processing

The decision in one paragraph

If your product is closer to "a chatbot that talks like a person", agentic mode will feel natural — the user can ask questions out of order, jump topics, or interrupt without breaking anything. If your product is closer to "a guided form" or "a deterministic decision tree", conversation flow will give you the visibility and predictability you want. Both modes share the same knowledge base, the same tools, the same widget, and the same APIs — you can build a project in either mode and switch later.

Side-by-side comparison

Aspect
Agentic
Conversation-flow
Configuration surface
Phases list — instructions + tools + exit per phase
Canvas — typed step nodes connected by ports
Position in conversation
state.variables.<phaseStateVar> (one string)
state.stack[].nodeId (graph position)
Branching
exitWhen DSL evaluated each turn against state
condition / buttons step output ports
LLM calls per turn
Up to 12 rounds inside one loop, one final reply
One per agent / prompt step that runs in the chain
Tool catalog
Per phase (allowlist on top of project tools + UI builtins)
Per agent step (toolIds[] + boolean toggles)
Off-script questions
Phase stays put; model uses available tools to answer
Behaviour depends on the listen / agent step you authored
Memory between turns
state.variables + conversation_memory string (no inter-turn message log)
state.variables + conversation_memory replayed into each LLM call
Visual editor
Phases list — linear, edit instructions / tools / exit
Drag-and-drop canvas with zoom, pan, port wiring
Best when
User can say anything at any point
You want every path visible and auditable

How a turn flows in each mode

Agentic — a turn

  1. Read active phase from session state
  2. Apply any button-tap state writes (immediate)
  3. Run phase-enter side-effects: KB context injection, declarative buttons
  4. Build prompt: persona + project instructions + phase instructions
  5. Filter tools by phase allowlist
  6. Run a single tool-calling loop until the model produces a final reply (max 12 rounds)
  7. Evaluate exitWhen; if true, advance phase and fire enter side-effects same turn
  8. Persist state, increment turn

Conversation-flow — a turn

  1. Read current step id from the session's stack frame
  2. Execute that step (LLM call, branch, set variable, API, …)
  3. Resolve next step from connections / step output
  4. Repeat until a step waits for input, ends, or hits the step limit
  5. A single user turn can run many steps — and many LLM calls
  6. Pause at listen / buttons / end
  7. Persist state, increment turn

Switching modes after launch

The runtime mode is decided per project by the framework field. You can change it later via the project settings or the persist API — the API surface, channels, knowledge base, and widget all stay the same. Changing modes does not migrate your existing canvas or phases automatically; the conversation-flow canvas and the agentic phases are independent configuration surfaces. Launch in the mode that best fits your product, and switch later if your needs evolve.

Next