Riseplan from Roast & Rise
From Chatbots to Superagents
Make the leap from quick chatbot answers to agents that do the heavy lifting, safely, reliably, and at scale.
Stop settling for one-off chatbot interactions. This plan shows you how to delegate real, repeatable work to AI agents with control, confidence, and results your team can trust.
Course thesis
The shift isn’t smarter prompts. It’s treating real work as bounded delegation, where AI agents handle jobs within clear contracts, using tools, context, and permissions, with review and escalation built in.
What you leave with
By the end, you can audit your team's chatbot habits, choose the right workflow to delegate, draft a superagent work contract, build a practical delegation loop, and run a 30-day superagent pilot that tracks trust, value, and risk.
For
Founders, operators, managers, AI owners, and nontechnical teams in SMB, hospitality, service, logistics, admin-heavy, and knowledge-work organizations ready to move from passive prompting to supervised delegation.
Workflow
Transition a team's use of AI from ad-hoc question-answering to running delegated, supervised AI agents that take on recurring tasks with trust, oversight, and improvement built in.
Change
Teams stop treating chatbots as one-off assistants and start structuring repeatable, valuable work as agent-delegated jobs with clear boundaries, review steps, and measurable outcomes.
What you can do
Use these as checks while you move through the plan.
Identify and break unproductive chatbot habits in daily workflows.
Select one recurring, impactful workflow ready for delegation to an agent.
Draft a complete agent work contract, mission, risks, context, inputs, allowed tools, permissions, sources, and quality bar.
Build and run a supervised delegation loop: briefing, review, escalation, and continuous improvement.
Measure adoption, value, quality, and risk through a real 30-day superagent pilot.
Chapters
01
Wake Up from Chatbot Sleepwalking
Stop drifting through daily chatbot prompts. See where your team is stuck in copy-paste cycles and surface hidden routines ready for actual delegation. This chapter gives you a clear map: what your team is really doing with chatbots, and which habits are costing you time, oversight, and trust.
Why this matters in the workflow
Most teams don’t use chatbots strategically. They drop random questions in, copy results, paste them elsewhere, repeat. No memory. No review. No improvement. The same prompts appear week after week in quick DMs, doc comments, or shared inboxes. The result: invisible DIY labor, doubled-up work, nowhere to spot patterns or step up to real delegation.
Moving to agentic workflows starts with daylight: mapping what’s actually happening, by whom, for what purpose, and whether it holds up. An audit clears the fog. It separates the useful from the endless improvisation, and sets up the first target for safe, trusted automation.
The working model
Quality checklist
Each prompt/task is captured exactly as used, not paraphrased.
For each, at least: who, frequency, input, output, review, and pain points are listed.
Tasks are clustered clearly, with overlaps and recurrences named.
Summary note clearly picks a candidate and says why it’s worth targeting.
Output allows another team member to double-check and spot the same patterns.
Common mistakes
Only writing down a few obvious prompts, missing weekly or edge-case repeats.
Skipping real pain points (copy-paste, errors, delays) and only tracking requests, not outcomes.
Failing to tag each with actual recurrences and frequency, makes it hard to see true workload.
Being too generic (“we use it for emails sometimes”) rather than concrete cases.
Presenting the audit as a negative performance review instead of a starting point for improvement.
Checkpoint
Can you point to one well-defined chatbot habit your team repeats often, and explain exactly how, where, and by whom it runs today?
Exercise
Do a Chatbot Habit Audit for Your Team
Steps:
- Pick one team, department, or function. Gather 2-5 people who use chatbots regularly.
- Pull up real chatbot histories from the last 2 weeks (apps, browser extensions, Slack integrations, capture the raw prompts and outputs).
- For each entry, fill in the 'Chatbot Habit Audit' fields below.
- Cluster usage examples by similarity. Mark each with: recurring (Y/N), value (High/Medium/Low), risk (High/Medium/Low).
- Spot clear candidates where delegation could save time, improve quality or reduce copy-paste pain.
- Produce a short note (max 5 sentences): the highest-leverage chatbot habit you found, and why it’s worth targeting next.
Deliverable: your filled audit plus the summary note.
Use this at work tomorrow
Run the audit for one routine chatbot use, capture verbatim prompts, frequency, output, and pain, then cluster and name one repeatable job ready for real delegation.
02
Spot the First Real Job to Delegate
Pick the right workflow for your first superagent handoff: it must be recurring, valuable, safe, and reviewable. This chapter guides you through listing, ranking, and choosing that first delegated job.
Why this matters in the workflow
Throwing random jobs at a new agent doesn't work. In most organizations, teams are stuck in one-off chatbot habits, asking, copying, pasting, hoping for magic. Meaningful delegation only happens when work is repetitive enough to learn, valuable enough to matter, low-risk enough to trust, and concrete enough to check.
In the pilot phase, your agent’s success is defined by smart selection, not by AI’s power, but by the fit between job and delegation. One good candidate is worth ten messy experiments.
The working model
Quality checklist
Tasks are real, recurring, and documented, not hypothetical.
Each task rated on frequency, value, risk, and checkability.
At least one clearly suitable candidate is picked and justified.
Rationale shows understanding of risk and value, real risk and value.
Anyone reading the output can see what was ruled in or out.
Common mistakes
Choosing one-off or rare jobs, agent pilot fizzles out.
Ignoring risk; selecting tasks with serious compliance or privacy consequences as a first test.
Picking subjective tasks where no-one agrees what ‘good’ is.
Listing tasks with no explicit benefit if delegated.
Skipping team discussion, no buy-in, process stalls.
Checkpoint
Can you name one real workflow your team will delegate to a superagent, and explain why it was chosen?
Exercise
Build Your Delegated Work Candidate Map
Steps (15 minutes)
- List 5–8 recurring tasks your team or department handles each week.
- For each, fill in: frequency, value, risk of error, checkability.
- Use the template to plot your candidates, high frequency and value, low/medium risk, checkable first.
- Circle or mark the best first pilot. Write 2 lines: why this is your pick, and what makes it safe to test.
Deliverable:
- A clear, ranked candidate map with one workflow chosen and rationale written.
Time: 15 minutes; work with real workflows.
Use this at work tomorrow
Map your team’s top recurring tasks by frequency, value, risk, and checkability. Pick the best candidate. Start your first real superagent pilot.
03
Draft the Superagent Work Contract
Turn vague AI prompts into a real job description. Set boundaries, permissions, tools, review rules, and escalation paths, so your agent is trusted, safe, and ready to deliver.
Why this matters in the workflow
Chatbots follow instructions. Superagents sign up for jobs. The difference is your contract. A sloppy prompt leads to wild-card results or invisible risks. A tight contract tells the agent what to do, what not to touch, which tools it can use, where to check in, and how success is measured. This is where you shift from hacking answers to delegating real work.
Teams that skip this step either get burned (the agent overruns its brief, exposes sensitive data, or muddles the job) or stall (trust never arrives, so agents are stuck at demo stage). Clarity brings control, inspection, and improvement.
The working model
Quality checklist
Mission is specific, jargon-free, and bounded
Context includes all relevant constraints and business rules
Inputs are complete, unambiguous, and accessible
Allowed tools are stated with no open-ended access
Permission ladder sets clear limits and approval points
Sources are authoritative, not ad-hoc or personal files
Review gates ensure human check before irreversible actions
Definition of done is observable and measurable
Escalation rules are practical and match real risk modes
Output is understandable and actionable by someone outside the team
Common mistakes
Leaving the agent mission too vague or broad
Granting blanket access to data or tools
Missing key approval steps, no review before high-impact actions
Forgetting to specify where to find reliable source data
Not defining how and when someone should step in if something goes wrong
Confusing 'review' with 'auto-approve'
Writing complex rules only a technical person can follow
Checkpoint
Can you produce a Superagent Work Contract that a teammate could review, understand, and use to supervise both the bot and the output?
Exercise
Write a Superagent Work Contract for One Delegated Job
Pick a workflow you genuinely want to delegate. Use the template below. Fill in each blank with live details. Invite a teammate to review for clarity and missing risks. You are not writing for the bot, you are writing for your team to trust and guide the bot.
Steps:
- State the delegated job as a mission, in one direct sentence.
- Specify the context: background, constraints, critical business rules.
- List the exact inputs the agent needs to start.
- Choose the allowed tools and systems.
- Map the permission ladder: no-go areas and approval steps.
- Point to the sources of truth and reference data.
- Define review gates: when and how humans check work.
- Set the definition of done.
- Write the escalation rules and stop conditions.
- Ask a colleague: Would you trust this agent to start? Would you know how to intervene if needed?
Use this at work tomorrow
Write a draft contract for one routine task you’d want an agent to take over, tighten the brief, limit permissions, and set the review steps before any code gets built.
04
Build the Delegation Loop, and Run It
Turn your superagent work contract from paper to practice. Set up the cycle: brief, run, review, escalate, and improve. Document decisions, check results, and get ready to repeat.
Why this matters in the workflow
Chatbots respond. Superagents deliver. But unless you set up a real-life delegation loop, brief, run, review, escalate, improve, you’re gambling with output, safety, and trust. Without the loop: mistakes slip through, risk isn’t caught, and agents drift out of bounds. With it: every job gets the context, oversight, and steady improvement that separates real work from toy demos.
The working model
Delegation is a rhythm, a loop, not a one-way street. For every job you delegate to an agent, run this cycle:
- Brief: Supply clear inputs, context, goals, and boundaries. Use your work contract as the brief.
- Run: Let the agent execute. Watch for alerts, anomaly signals, or blocks.
- Review: Human review at pre-set gates. Did the output hit your quality and risk bar?
- Escalate: If there’s a miss or uncertainty, flag and escalate, never let it slip through unattended.
- Improve: Log feedback, update the brief, retrain the agent, or adjust review steps. Close the loop for next run.
Quality checklist
Clear, specific agent job and context for this run.
Briefing matches the latest work contract and inputs.
Full output captured and attached.
Human review uses the team’s real rubric, clear evidence instead of gut feel.
Escalation, if needed, is documented and routed to the right owner.
Improvement action is relevant and actionable for the next cycle.
Common mistakes
Skipping review and signing off by default.
Forgetting to capture the actual output or changes made.
Letting escalations or misses go undocumented.
Leaving improvement actions vague.
Assigning unclear ownership to review or escalation.
Checkpoint
Did you document a full real (or simulated) delegation loop, brief, agent output, review, escalation, and one improvement, for your chosen workflow?
Exercise
Run Your First Delegation Loop
Instructions
- Pick your chosen superagent workflow (use your work contract from the previous step).
- Set up ownership: Decide who will brief, review, approve, and escalate in this first cycle.
- Prepare your tools: Create a simple shared document, checklist, or workspace. Make space to capture every step.
- Run the cycle:
- Write out your briefing notes for the agent, including any new context for this run.
- Trigger the agent. Let it run, monitor execution.
- Review the output using your review rubric. Note all feedback.
- If something is unclear, risky, or wrong, document and simulate the escalation process.
- In your document, write a one-paragraph improvement note.
- Output: Save the complete play-by-play record for this cycle: brief, output, review, escalation notes, improvements.
Complete the loop with sample or real data in under 15 minutes.
Use this at work tomorrow
Run your next recurring job through this loop, appoint an agent manager, document the cycle, and collect one lesson for improvement.
05
Pilot, Measure, and Raise the Bar
Run a 30-day superagent pilot and track the hard numbers, time saved, rework, adoption, and risk. Use a scorecard and debrief to decide whether to scale, fix, or stop. Trust the data before you trust the feeling.
Why this matters in the workflow
Delegating work to a superagent isn’t a one-off event. It’s a shift, manual to managed, quick chats to continuous delegation. But what actually changed? What got better? What needs fixing? The 30-day pilot is where intent meets reality. You can only manage what you measure.
Most teams stop at launch. Those teams stall, or worse, suffer silent errors and slow adoption. You want proof: Is this working? Should we trust it? Where does it break?
The working model
Quality checklist
Scorecard captures every agent workflow instance, including weak runs and risk events.
Time saved and adoption are tracked and compared to the old process.
Rework, risk events, and escalations are logged directly, not smoothed over in summary.
Debrief is based on both numbers and honest team feedback.
The decision (scale, pause, or stop) is clear, with a concrete next action.
Common mistakes
Only tracking technical success, not adoption or time impact.
Failing to log negative outputs, rework, or risk events.
Letting the old process run untracked in parallel, masking low adoption.
Treating debrief as a routine report, not a feedback-driven session.
Ignoring disagreement or unease from key users.
Checkpoint
Can you show a filled scorecard and clear debrief note that highlights time saved, major fixes, adoption, and a next action?
Exercise
Run Your 30-Day Superagent Scorecard and Hold a Pilot Debrief
How to do it
- Download or copy the scorecard and debrief template below.
- For each instance of the delegated workflow, log the date, agent output, review result, time saved, rework needed, and any risk or escalation event.
- At least weekly, update adoption (who used the agent vs. the old way) and list feedback or surprises.
- At day 30, invite everyone involved to a 30-minute debrief. Screen-share your filled scorecard. Invite honest feedback, what worked, what failed, what’s missing?
- Summarize: Will you expand, adjust, or pause? What’s the exact next action?
Use this at work tomorrow
Copy the pilot scorecard and start logging every agent run. Hold a short debrief with honest talk, not a celebration exercise.
30-day path
Kick off with a chatbot habit audit in week 1.
Map and shortlist candidate workflows by week 2.
Draft and review the superagent work contract by week 3.
Set up and test the delegation loop before launching the agent at the end of week 3.
Run the real workflow using the agent for 30 days, tracking, reviewing, and improving as you go.
Hold a pilot debrief session and decide the next move by day 30.
Success signals
Number of workflows with documented superagent contracts.
Reduction in one-off chat prompts for selected workflow.
Time saved and rework rate after deploying the agent.
Quality score of agent outputs versus baseline manual work.
Incidence of risk or escalation events during the pilot.
Clarity and adoption by non-technical users.
Reflection prompts
Where does this topic show up in real work?
What behavior should change first?
What evidence would prove this Riseplan worked?
Manager checklist
Choose one owner for the behavior change.
Use the exercise on live work.
Review the output before scaling the habit.
Decide what changes after 30 days.
Want this shaped around your company?
Risey can research your company foundation first, then build a version of this path around your real workflows, customers, and culture.
Start with your company