Storyboard & Scenes — Your Character’s Playbook

Think of your AI character as the star of its own little show. This guide helps you turn one idea (“a character that helps my visitors”) into a working show — a Storyboard made up of Scenes — so your character stays on track, changes topics at the right moment, and only ever reaches for the exact books and tools it needs in each moment.

Here’s the one idea that makes everything click:

Companion guide: the Tools guide (the “CallFunc Operation Manual”). A tool is like handing your character a phone so it can call another app and get something done. Tools get attached per scene, so the two guides fit together: this one designs the show; that one designs the tools each scene can use. Keep both handy.

A quick promise: this guide is honest. Where the buttons on screen don’t quite match what’s possible behind the scenes (it happens in a couple of spots), we’ll tell you plainly, so you never waste time hunting for a setting that isn’t there.

1. The big idea: scenes are steps, not personalities

Picture your show like a comic strip, or the scene list for a movie, or a flowchart for a help desk call:

Each box is a Scene. Every scene has:

• a Goal — one or two sentences saying what this scene is for. Think of it as the sign on the door: it tells your character “come here when the visitor wants THIS.” This is how your character knows which scene to walk into.
• an Instruction — the playbook your character follows while it’s in that scene: its tone, its rules, what to do, what not to do.
• its own books (the documents it can answer from), its own tools (the apps it can call), and its own motions (little avatar animations).

The arrows between boxes are the paths — they say “from here, you can go there.”

Why break a show into scenes instead of writing one giant instruction? Because a small, focused scene:

• keeps your character’s instructions short and clear (less room to ramble or contradict itself);
• only puts the tools and books in front of it that matter right now (an “answer questions” scene literally can’t trigger your “issue a refund” tool, because that tool isn’t in that scene);
• lets you be stricter in some scenes than others (very strict for “answer from the manual,” relaxed for friendly chit-chat);
• gives you a picture of the whole experience you can actually see and share — not a wall of text.

2. The pieces you’ll work with

Here’s everything in plain terms. You build all of this by clicking around the console — no code for the show itself. (The only time you’d touch code is if a tool needs a custom backend, and the Tools guide walks you through that.)

3. The two boxes you fill in for every scene

When you open a scene to edit it, you’ll mainly fill in two boxes. Don’t overthink which one a rule “belongs” in — your character reads them together. Here’s what each is for:

The Welcome scene is a little special

Your first scene — the Welcome scene where every visitor lands — plays by slightly different rules:

• Its “sign on the door” (Goal) doesn’t do anything, so the console hides that box for the Welcome scene. Don’t worry about filling it in.
• Its Instruction is always switched on, in every scene. So whatever you write here acts like house rules for the whole show — your character carries it everywhere.
• Your character can never be routed back to the Welcome scene once it leaves. It’s the front door, not a place to return to.
• It has exactly one arrow out, pointing to the first “real” scene the conversation lands on.

4. Build it step by step (clicking through the console)

Let’s build a friendly “ACME Concierge” helper with four scenes — one of each type from Section 5. The button labels below should match what you see; if yours look a little different, match by meaning.

Step 0 — Create the storyboard

Step 1 — Lay out your scenes

Step 2 — Connect them with arrows

A few things the canvas won’t let you do (by design):

• a scene can’t loop an arrow back to itself;
• nothing can point an arrow into the Welcome scene;
• the Welcome scene gets exactly one arrow out (say, Welcome Desk → Product Help).

Draw the picture from Section 1.

Step 3 — Fill in each scene

Step 4 — Give each scene its books, tools, and motions

Step 5 — Set the show-wide behavior

Step 6 — Try it out

If it doesn’t switch scenes the way you expect, your signs on the door overlap or are too vague — see Section 6.

5. The four kinds of scene

Most scenes are one of four types. Designing a show is mostly picking which of these you need and giving each a clear sign on the door. For each, here’s what it’s for, what to write, and what to attach.

5.1 The Greeting scene (usually your Welcome scene)

• What it’s for: welcome the visitor, set the tone, find out what they need, and quietly catch the facts you’ll reuse later (their name, an order number, their plan).
• Goal: the Welcome scene’s goal isn’t used for routing, so leave it generic or blank. (If instead you’re making a non-Welcome “front desk” that points people onward, write something like “Figure out what the visitor wants and send them to the right place.”)
• Instruction: “Greet the visitor warmly in a sentence or two. Ask what they need help with. If they mention an order, note the order number. Don’t try to solve the problem here — just find out what kind of help they need.” Keep it short.
• Books: light — maybe a “what ACME does” overview. (Remember, Welcome-scene books are always available everywhere.)
• Tools: usually none. Don’t let your character take real actions before it even knows what the visitor wants.
• How it starts: set it to speak first, with a greeting.

5.2 The Answer-Questions scene

• What it’s for: answer questions straight from a specific, trusted set of documents.
• Goal: “Answer questions about ACME products — setup, features, troubleshooting, compatibility. Use only the product documents.” A specific sign means clean routing.
• Instruction: “Answer from the attached product docs. If the docs don’t cover it, say so and offer to connect a human — don’t guess.”
• Books: attach the product docs. This is what makes the scene answer only from those exact files.
• Tools: none, or simple tools that only look things up (they don’t change anything).
• Best paired with Precise chat mode (Section 8) — it tells your character to stick to what it’s given and admit when it doesn’t know. Perfect where a wrong answer would be bad.

5.3 The Get-Something-Done scene

• What it’s for: actually do a thing — look up an order, start a return, book a meeting — by using a tool.
• Goal: “Help the visitor with an existing order: check status, change the address, or start a return.”
• Instruction: “Use the order-status tool to look up orders. To start a return, use the return tool — but confirm the order and reason with the visitor first.” Refer to your tools by name.
• Books: maybe a returns-policy doc.
• Tools: attach the relevant tools here. For anything that changes things or can’t be undone (returns, payments), turn on the tool’s “Require end-user confirmation before API calls” setting so the visitor approves before it runs (see the Tools guide).

5.4 The Wrap-Up / Pass-to-a-Human scene

• What it’s for: the closing moves — confirm something worked, hand off to a real person, or say goodbye.
• Goal (wrap up): “Confirm what was just done and close out the conversation.” Goal (handoff): “Hand off to a human when the visitor is frustrated, asks for a person, or hits something we can’t handle.”
• Instruction: “Summarize what was done and the next steps. Ask if there’s anything else.” — or for a handoff: “Acknowledge the visitor, collect a short note on the issue, and let them know a human will follow up.”
• Books / Tools: maybe a “create a ticket” or “notify a teammate” tool for the handoff; otherwise none.

6. How your character moves between scenes: Goal vs Flow

This is the heart of designing your show. There are two ways to set up scene-switching, and you pick one for the whole show in Settings → General.

Both modes work the same way underneath: when a visitor says something, your character reads the signs on the doors (the Goals) and walks into whichever scene matches what the visitor actually means (not just matching keywords). The only difference between the two modes is which scenes your character is allowed to walk into from where it is.

6.1 Goal mode — let it roam (the default, and the friendliest)

• What it does: from anywhere in the show, your character can jump to any scene whose sign matches what the visitor wants. It feels like a smart assistant that just knows where to take you.
• You still draw arrows, but in this mode think of the arrows as “these scenes are part of this show,” rather than “you may only step here from there.”
• Use it when: topics are independent and visitors hop around freely — help desks, concierges, FAQs. This is the default, and what most projects want.

6.2 Flow mode — put it on rails

• What it does: your character can only move along the arrows you drew. A guided, scripted path, one step to the next.
• Use it when: order matters — sign-up wizards, qualifying questions, checkout — anything where “you have to finish step 2 before step 3.”

Goal mode (let it roam): the arrows just say which scenes exist.
   Welcome → A → B → C     From B, the visitor can still jump to A or C — any scene.

Flow mode (on rails): the arrows are the only paths.
   Welcome → A → B → C     From B, you can only step to B's direct neighbor (here: C).

6.3 What a switch feels like

When your character switches scenes, it happens smoothly, mid-answer. The avatar or name on screen may update, and the same reply continues using the new scene’s instructions, tools, and books. No “please hold, you’ve been transferred, now repeat yourself.”

6.4 If switching goes wrong — read this before you pull your hair out

• Your character only reads the Goal (the sign on the door). It does not read panel names, arrow names, or arrow notes. So if it’s switching to the wrong scene, fix the Goals, not the labels on your arrows.
• Vague or overlapping signs cause bad switching. When two signs could both match, your character prefers to stay where it is. So make each sign a distinct, specific intent. A sign that says “Help the visitor” matches everything and routes nothing.
• A scene with no arrow into it is invisible. In Goal mode, if no arrow points into a scene, your character can never reach it — even if the sign matches perfectly. Draw at least one arrow into every scene.
• A blocked switch is silent. If your character tries to go somewhere the mode doesn’t allow, the reply just continues in the current scene — no error pops up. If it “won’t switch,” check that there’s an arrow into the target (Goal mode) or a direct arrow to it (Flow mode).

7. Filling in the blanks automatically (variables)

Sometimes you want your character’s words or tool calls to fill in a detail on the fly — like the visitor’s name. Two simple systems handle this.

Things learned from the conversation

• What it is: details your character picks up live as you talk — the visitor’s name, their order number, their plan.
• How to use it: you write a placeholder like {$context.user.name} right inside a scene’s Goal or Instruction (or in a tool’s web address or its settings). When your character learns the value, it fills the placeholder in.
• You set up the shape of these (what details to watch for) on the storyboard — you describe the structure, you don’t fill in the values yourself.

Fixed settings you set once

• What it is: fixed values you decide and that never change — a web address, an account id, a fixed path.
• How to use it: add them to the storyboard’s Variables list, then drop them into Goals, Instructions, or tools the same way. Your character never asks the visitor for these.

8. The behavior knobs (and where they live)

These all live in Settings → General and apply to the whole show, not one scene.

8.1 Chat mode — how strict your character is

• Precise (the default): tells your character to stick strictly to the info it’s given, admit when it doesn’t know, and use the source’s own wording. Best for answer-from-the-manual scenes.
• Free: relaxed, open, creative, chit-chat-friendly.

8.3 How your character starts the conversation

• Proactive (the default): your character speaks first, using the greeting you set. If you leave the greeting blank, your Welcome scene’s Instruction drives the opening line (one more reason to put care into the Welcome scene). Returning visitors who’ve talked before aren’t re-greeted.
• Passive: your character waits for the visitor to speak first (more of a “search box” feel).

8.4 Little nudges and suggestions

• Suggested prompts: ready-made starter chips that appear when someone connects.
• Follow-up questions: your character suggests sensible next questions after it answers (you can show between 1 and 5).
• Idle nudges: gentle “still there?” prompts after a quiet stretch — needs both the toggle turned on and a nudge message written.

8.5 Motions (avatar animations)

Little per-scene avatar animations. Some play based on what your character is saying; some play based on state (idle, talking). Welcome-scene motions are always available, so they act like your show’s default animations. A few timing details are handled automatically — don’t over-invest in fiddling with them.

9. The three kinds of “knowledge” (and what each is for)

Your character can draw on information in three different ways. They’re easy to mix up, so here’s the plain version:

10. Keeping it safe and pleasant

Here are your main levers for a trustworthy, friendly experience:

11. When something’s not working

12. Why scenes? (the honest pros and cons)

This scene-based way of building is one approach among several. Here’s how it stacks up against the ways people often start.

What’s great about it

• Focused and safe by design. Each scene is small and only sees the tools and books it needs. A casual question scene cannot trigger your refund tool — that’s enforced by where you attached the tool, not by hoping a long instruction holds. This is the biggest win.
• Tune each scene on its own. Strictness, books, tools, and animations are set per scene. One giant instruction would have to be a single compromise for every situation.
• You can actually see it. Your show is a picture you can look at, hand to a teammate, and change in the console — no code, no digging through one massive paragraph.
• No code for the show. You design a multi-step experience without writing any program; the platform handles the back-and-forth, the voice, the memory, and the safety.
• Smooth switches. Topic changes happen mid-reply, so the visitor never feels dropped or transferred.

The honest limits

• Switching is only as good as your signs. Your character routes by reading the Goals and nothing else. Vague or overlapping signs route badly. Writing crisp, distinct signs is the work.
• Some knobs are whole-show, not per scene. Chat mode (Precise/Free) applies to the entire show. You can’t make one scene Free and another Precise.
• It’s one character, not a team. Scenes change what one character is doing; they don’t let two separate specialists genuinely team up. If you truly need multiple experts working together at once, this isn’t that (and that capability isn’t available yet).
• A couple of arrow features aren’t wired up. “Set a value when this arrow is taken” and “jump to another whole show” exist as ideas but don’t actually run yet. Don’t design around them.

How to think about it

• Reach for scenes whenever your character has more than one distinct job — different tools, different books, or different strictness per step. That’s the common case for product, support, and concierge characters, and it’s exactly what this is built for.
• A single scene is totally fine for a tiny one-job character — that’s just “a show with one scene.” You lose nothing by starting there and splitting later.
• If you find yourself wanting total free-form autonomy or a team of collaborating experts, you’ve outgrown what scenes do. Most projects don’t need that — the scene approach gets you a trustworthy, shippable character far faster.

13. The one-page recap

1. A Scene is one moment of your show — one job your character is doing. A Storyboard is the scene list that wires them together. It’s one character changing what it’s doing scene to scene.
2. Two boxes per scene: Goal & Scope (the sign on the door — what this scene is for) and Instruction (how to behave here).
3. Your character routes by reading the Goal. Write Goals that are specific and distinct — vague signs route badly. The Welcome scene’s goal isn’t used, so put your care into its Instruction.
4. Two switching modes: Goal (let it roam to any scene — the default, best for most) or Flow (on rails, only along the arrows you drew).
5. Tools and books live inside scenes — that’s your main safety net. Turn on “Require end-user confirmation before API calls” for anything risky. Add a handoff scene as an escape hatch.
6. Fill-in details: some are learned live from the chat; some are fixed values you set once.
7. Whole-show knobs: Precise vs Free; speaks-first vs waits.
8. Two kinds of knowledge: per-scene books, and per-scene pictures to show.
9. Start small, then grow — the fewest scenes that cover your job, Goal mode, clear signs.
10. Publish to go live. Tweaks don’t reach real visitors until you hit “post.”