|
IBM BOB V2.0 — FORTNIGHT 6 OF 6
V2 Power
Subagents · Parallel Tasks · New Modes · Rollback · Workflows
IBM Bob V2.0 reached general availability on June 24, 2026 — faster, agentic, and built on a single unified agent.
Master everything new in IBM Bob 2.0 — the ground-up rebuild that makes Bob faster, agentic, and unified
Weeks 11–12 • Labs 12–14 • All Labs •
|
|
Fortnight 6 Overview — What's New in V2.0
IBM Bob V2.0 is a ground-up rebuild on a single unified agent that behaves identically across every client. This fortnight covers everything that changed, so you can work the V2 way.
• Single agent, three-tier architecture: Agent (reasoning) + Harness (infrastructure) + Clients (IDE, Shell). No duplicated logic.
• Subagents: Bob spawns focused subagents with their own clean context for self-contained subtasks; only the summary returns.
• Parallel native tool calling: Multiple tools run in one turn. ~30s tasks now finish in under 10s. Context window up from 200k to 270k tokens.
• Three modes: The five old modes fold into Agent, Plan, and Ask.
• Background tasks + Rollback: Run several tasks at once; rollback tracks file state per task, turn, and tool call — no git required.
• Workflows: A framework that makes large, multi-phase changes repeatable — mixing automation, AI, and human approval steps.
Prerequisites: Fortnights 1–5, or existing Bob V1 experience. Upgrade: Installing V2 is the only step — settings, rules, and MCP servers carry over.
|
|
FN 1 ✓
Get Started
|
FN 2 ✓
Build & Review
|
FN 3 ✓
Modernize
|
FN 4 ✓
Ship & Scale
|
FN 5 ✓
Automate
|
FN 6 ← NOW
V2 Power
|
Fortnight 6 — Learning Plan
|
WEEK 11 | The V2 Agent: Subagents, Parallel Speed & Three Modes
The V2 Agent: Subagents, Parallel Speed & Three Modes
|
|
Objective: Understand the V2 architecture, use subagents to keep context clean, exploit parallel tool calling for speed, and adopt the new three-mode model (Agent / Plan / Ask).
📖 Required Reading
• Bob V2: Faster, better, smarter (release announcement) — read this first; it frames the whole fortnight
• Welcome to IBM Bob — updated for V2, now describes subagents and three modes
• Modes — the new Agent / Plan / Ask model
• Changelog — version-specific V2 updates
• Best practices — updated guidance for the V2 workflow
🎬 Videos (youtube.com/@ibm-bob)
• Your Agentic AI Coding Partner — the V2 agentic model
• Concept to Code: Architect a New Feature — Plan → Agent handoff
🔑 The Three V2 Modes
|
Mode
|
What it does
|
When to use
|
|
Agent
|
Takes action and completes the task with full agentic capabilities
|
Once the work is clear — implementation
|
|
Plan
|
Gathers requirements, discovers context, checks understanding, produces an actionable plan
|
Unfamiliar code or a change with real surface area
|
|
Ask
|
Read-only. Explains architecture and logic without touching the codebase
|
Understanding before changing anything
|
|
💡 V2 Migration Note (from V1)
• V1's five modes (Code, Ask, Plan, Advanced, Orchestrator) fold into three: Agent (was Code + Advanced + Orchestrator), Plan, and Ask.
• Read operations (read files, list directories, search) are now approved by default — Bob gathers context without stopping. State-changing actions (edits, commands, MCP calls, skill invocations) still require approval.
• Checkpoints are renamed to rollback and no longer require git.
|
🔬 Lab This Week
• Lab 12: Subagents & Parallel Speed — spawn a subagent to investigate a codebase and feel the V2 speed difference (Section: Labs)
✅ Week 11 Checklist
□ Installed / updated to IBM Bob V2.0 (settings and rules carried over)
□ Confirmed the three-mode model: Agent, Plan, Ask
□ Started a task in Plan mode and handed the plan to Agent
□ Approved a subagent spawn and reviewed the summary it returned
□ Noticed read operations no longer prompt for approval
□ Observed the quieter V2 chat (intermediate tool calls collapse away)
|
|
WEEK 12 | Background Tasks, Rollback, Documents & Workflows
Background Tasks, Rollback, Documents & Workflows
|
|
Objective: Run multiple tasks in the background, restore precise states with rollback, work directly with documents, and make large multi-phase changes repeatable with Workflows.
📖 Required Reading
• Checkpoints / Rollback — V2 rollback: per task, per turn, per tool call
• Context window management — the larger 270k window and auto-compaction
• Working with large projects — where Workflows fit for enterprise-scale change
• Skills — Skills tab in settings; building blocks for Workflows
• Enterprise plan overview — Premium Packages ship tested Workflows
🎬 Videos
• From Observability to Action — measuring V2 impact
• Deploy with Confidence: DevOps Plays — repeatable multi-phase change
📄 Working with Documents (new in V2)
|
• V2 reads .docx, .pdf, and .xlsx files natively — drop one into the conversation and Bob works from it directly, no copy-paste or extraction.
• At the end of an analysis task, Bob can produce a single self-contained HTML summary — one page, opens in any browser, shareable with people who weren't in the session.
|
⚙️ Workflows — Making Multi-Phase Changes Repeatable
|
The three kinds of workflow step
• Plain automation — scanning dependencies, running tests. No AI needed.
• AI steps — complex code transformations, pattern analysis.
• Human steps — approving a strategy, reviewing diffs before commit.
A Workflow defines where each step belongs. The engine runs steps in order, holds state, handles errors, and makes the whole process repeatable. This is how IBM's Premium Packages (Java Modernization, IBM i, IBM Z) ship tested, opinionated workflows.
|
🔬 Labs This Week
• Lab 13: Background Tasks, Rollback & Documents — run parallel tasks, restore a precise state, analyse a document
• Lab 14: Design a Workflow — map a multi-phase change into automation / AI / human steps
✅ Week 12 Checklist
□ Ran at least two tasks in the background simultaneously via the task panel
□ Restored a precise state using rollback (per turn or per tool call)
□ Dropped a .docx, .pdf, or .xlsx into a conversation and had Bob work from it
□ Generated a self-contained HTML summary from an analysis task
□ Mapped a real multi-phase change into automation / AI / human steps
□ Identified which IBM Premium Package Workflow fits your estate (Java / IBM i / IBM Z)
|
Fortnight 6 — Labs
Labs use github.com/IBM/bob-demo and your own projects. Requires IBM Bob V2.0 (GA June 24, 2026). Update via bob.ibm.com/download.
Lab 12 — Subagents & Parallel Speed
|
Overview
Time: ~50 min | Difficulty: Intermediate | Modes: Agent, Ask
Goal: Spawn a subagent to investigate a codebase with clean context, and feel the V2 parallel tool-calling speed difference.
|
Part A — Feel the Speed
1. Open a real repo. Clone and open a codebase with some depth:
|
git clone https://github.com/IBM/bob-demo.git
|
2. Run a fan-out task in Agent mode. Ask something that requires several file reads and searches at once:
|
@/bob-get-started Read the main source files, the package.json, and the Dockerfile,
then summarise the architecture and how the pieces connect.
|
Notice Bob requests several tools in one turn rather than one at a time. In V2 this typically completes in under 10 seconds where V1 took ~30.
Part B — Spawn a Subagent
3. Give Bob a self-contained investigation. This is the ideal subagent trigger — a focused question whose intermediate steps don't matter to your main thread:
|
Figure out how authentication and request validation work in this codebase.
Spawn a subagent to investigate and report back only the summary.
|
4. Approve the spawn. V2 asks you to approve each subagent before it starts. Approve it.
5. Review the returned summary. The subagent reads files, traces calls, and works out the pattern in its own clean context. Only the summary returns to your main conversation — the intermediate file reads are discarded, keeping your main context clean.
6. Confirm context stayed clean. Check that your main conversation didn't fill up with the subagent's file reads and searches — that's the whole point.
|
✅ Lab 12 Success Criteria
• Observed parallel tool calling (multiple tools requested in one turn)
• Approved a subagent spawn and received a clean summary back
• Your main conversation context stayed focused, not cluttered with intermediate steps
• You can explain when a subagent is the right tool vs doing the work inline
|
Lab 13 — Background Tasks, Rollback & Documents
|
Overview
Time: ~55 min | Difficulty: Intermediate | Modes: Agent, Plan
Goal: Run parallel background tasks, restore a precise state with rollback, and have Bob work directly from a document.
|
Part A — Background Tasks
7. Start a task in Plan mode. Plan a feature, then hand the plan to Agent and let it run:
|
Plan and then implement: add a priority field (low/medium/high) to the todo API,
with validation and README documentation. Run it in the background.
|
8. Start a second task. While the first runs, open a new task and work on something else — e.g. ask a question about a different part of the repo. Both run independently, each with its own thread and context.
9. Use the task panel. Open the task panel to see what's running, what's done, and what needs attention. Confirm a finished background task did not pull your focus or switch your tab.
Part B — Rollback
10. Make several changes in one task. Let Agent make a sequence of edits across a few turns.
11. Restore a precise point. Open rollback. Unlike V1 checkpoints, V2 tracks file state per task, per conversation turn, and per individual tool call. Restore to a specific tool call — not just a coarse checkpoint.
12. Confirm no git needed. Note that rollback works even in a repo without git history — it tracks file state directly in the agent.
Part C — Working with Documents
13. Drop in a document. Drag a .docx, .pdf, or .xlsx into the conversation — for example a spec or a spreadsheet of test cases. Bob reads it natively.
|
@spec.docx Implement the API described in this document. Follow it exactly.
|
14. Generate an HTML summary. After an analysis task, ask:
|
Produce a single self-contained HTML summary of your findings that I can share.
|
|
✅ Lab 13 Success Criteria
• Two tasks ran in the background at once via the task panel
• Restored a precise state with rollback (per turn or per tool call)
• Bob worked directly from a .docx / .pdf / .xlsx with no copy-paste
• Generated a shareable self-contained HTML summary
|
Lab 14 — Design a Workflow
|
Overview
Time: ~45 min | Difficulty: Advanced | Modes: Plan, Agent
Goal: Map a real multi-phase change into a repeatable Workflow, classifying each step as automation, AI, or human.
|
|
⚠ About Workflow authoring
At V2 GA, the available Workflows are the ones that ship with Bob and the IBM Premium Packages (Java Modernization, IBM i, IBM Z). Broader authoring opens up as the API surface settles with early adopters. This lab focuses on designing a workflow so you're ready — and on running a shipped Premium Package workflow if you have access.
|
Steps
15. Pick a repeatable multi-phase change. Choose something your team does more than once — e.g. "migrate a service to Java 21", "convert fixed-format RPG to free-format across a library", or "add observability to every endpoint in a service".
16. Break it into phases. In Plan mode, ask Bob to decompose it:
|
Break this multi-phase change into ordered steps: [describe your change].
For each step, tell me whether it is best done by plain automation,
by AI, or by a human — and why.
|
17. Classify each step. Using the V2 model, tag each step:
□ Plain automation — dependency scans, running tests, compiling
□ AI — complex code transformations, pattern analysis, doc generation
□ Human — approving the strategy, reviewing diffs before commit
18. Identify the matching Premium Package. Map your change to an IBM Premium Package Workflow: Java Modernization, IBM i, or IBM Z. If you have access, run one shipped workflow end-to-end and observe how it holds state and handles errors across phases.
19. Document the workflow. Have Bob produce a one-page HTML summary of your workflow design that you can share with your team.
|
✅ Lab 14 Success Criteria
• A real multi-phase change decomposed into ordered steps
• Every step classified as automation, AI, or human with a rationale
• Mapped your change to the correct IBM Premium Package Workflow
• Produced a shareable one-page summary of the workflow design
|