Demo Walkthrough
If you are opening Clawback for the first time and wondering "what am I supposed to do here?", follow this exact path.
Audience: Friends, evaluators, and first-time users inside a seeded local workspace or any workspace where access has already been provided.
What This Demo Is
The current demo is focused.
It is not trying to cover every possible business workflow at once.
It is meant to show one answer-to-action path:
- grounded context from internal docs
- a useful assistant response
- a draft of a real next step
- a human review boundary before a consequential action
- durable work and audit state after the run
There are two starting points:
- worker-first admin path through
Setupand the worker proof rail - retrieval-first evaluator path through
KnowledgeandIncident Copilot
Before You Start
Keep these expectations in mind:
- this is a shared disposable demo workspace
- some data may already exist from earlier runs
- not every provider path is configured in the demo
- admin users should start from
Setup - evaluator users should start from
KnowledgeorChat
Choose Your Path
Path A: Worker-first admin path
Go to:
/workspace/setup
Click:
Run sample activity
That should land you on the follow-up worker at focus=proof.
If the proof rail already shows recent inbox or work state, open it directly.
If not, use:
Run sample activity
What to notice:
- a worker can be installed and configured as a durable role
- a real input can create inbox, work, and activity state
- the product is more than a chat thread
Then open:
/workspace/work/workspace/inbox/workspace/activity
What to look for:
- a durable work item created by the sample intake
- a reviewable inbox item when the worker needs sign-off
- audit truth that remains visible after the action path starts
Path B: Retrieval-first evaluator path
Go to:
/workspace/connectors
Inspect:
- the seeded
Incident Copilot Democonnector - the completed sync job
What to notice:
- answers can be grounded in a known corpus
- the no-Google retrieval path is real before live systems are connected
Then go to:
/workspace/chat
Use:
Incident Copilot
Ask these prompts in order:
Why did checkout fail last night?What should we do next?Draft a follow-up ticket for the team.Go ahead and create the ticket.
What to notice:
- the assistant can answer using the seeded knowledge source
- the response can move toward a concrete operational next step
- the system can prepare a reviewable action, not just generate text
Then inspect:
Go to:
/workspace/inbox/workspace/work/workspace/activity
What to notice:
- retrieval-backed chat can still produce durable work and review state
- outcome truth remains visible after the conversation ends
If You Want To Automate XYZ For Your Business
The right way to think about Clawback is not:
- "Where is the magic automation button?"
The right way is:
- what starts the work?
- what context should the worker use?
- what draft or action should it produce?
- what must require review?
- where should the outcome remain visible afterward?
In product terms, that usually maps to:
| Your business question | Clawback primitive |
|---|---|
| What starts the job? | route, connection, or chat prompt |
| What knowledge should it use? | knowledge source / connector |
| What behavior should it follow? | worker or assistant |
| What needs sign-off? | review boundary |
| What should happen next? | governed action |
| Where do I see the result later? | inbox, work, activity |
Examples:
| Business goal | Likely Clawback path |
|---|---|
| Draft a customer follow-up | inbound email or chat -> follow-up worker -> review -> approved send |
| Investigate an incident and create a ticket | knowledge source -> incident copilot -> ticket draft -> review -> create ticket |
| Turn notes into a proposal draft | uploaded notes or brief -> proposal worker -> draft artifact -> review or revise |
Good Questions To Ask After The Demo
If a friend says "Could this automate my workflow?", the next useful questions are:
- what event should trigger the work?
- what internal docs or records should it see?
- what should it draft versus execute?
- what absolutely needs human approval?
- who should own review?
- what should show up in
Workwhen it is done?
If you can answer those, you can usually sketch a real Clawback flow.
What The Demo Does Not Cover Yet
This demo does not cover:
- every integration is plug-and-play
- the product already automates every business workflow
- the current assistant list is the final product taxonomy
What it does show:
- grounded assistant
- reviewable output
- governed action
- durable visibility after execution