🧠 Agentic Tooling 2.0 (Beta)
Agentic Tooling 2.0 is currently in Beta and will supersede the existing Agentic Tooling at a future date. It works exclusively with reasoning models — advanced AI models that can think through problems step-by-step before acting. Using it with non-reasoning models will result in degraded performance or unexpected behaviour.
What is Agentic Tooling 2.0?
Agentic Tooling 2.0 is a next-generation execution mode for complex, long-running tasks. Your agent autonomously decides which tools to use, when to use them, and how to combine them — adapting its approach as it goes, like an adaptive digital worker that thinks on its feet.
Instead of following a fixed recipe, the agent thinks through your request, picks the right tools, uses them in the optimal order, and course-corrects when results change the picture — all while staying focused across tasks that involve many steps.
How It Differs from Legacy Agentic Tooling
| Aspect | Legacy Agentic Tooling | Agentic Tooling 2.0 |
|---|---|---|
| How it works | Follows a fixed step-by-step recipe — plan, execute, verify | Thinks through each decision and picks the best tools for the job, adapting as it goes |
| Planning | Creates a plan upfront and follows it rigidly | Adapts the plan on the fly as new information comes in |
| Stays on track | Can lose context over long tasks | Remembers what it was doing and why — stays focused across long-running tasks |
| Speed | Works through tasks one at a time, in order | Runs independent tasks at the same time for faster results |
| Handles errors | Retries with fixed strategies | Diagnoses what went wrong and tries a smarter approach |
| Model requirement | Any tool-calling model | Reasoning models only (models with deep thinking capabilities) |
The Three Agent Modalities
When configuring an Operator agent, you can choose from three modalities:
Operator (Default)
Standard agent behaviour. The agent responds directly to your messages. Best for simple Q&A, straightforward conversations, and quick lookups.
Agentic Tooling (Legacy)
The original agentic tooling. The agent follows a fixed sequence of planning, execution, and verification steps. Best for reliable, predictable multi-step tasks and backwards compatibility.
Agentic Tooling 2.0 (Beta)
Your agent becomes an adaptive digital worker — it autonomously decides which tools to use, in what order, and how many times. It stays focused across long-running tasks and adapts its strategy as it goes. Best for complex, multi-faceted tasks that require real-time decision-making and maximum flexibility.
You can switch between modalities at any time in your agent settings under Settings > Agents > [Your Agent] > Agentic mode.
How to Enable Agentic Tooling 2.0
- Navigate to Settings > Agents
- Select your Operator agent (or create a new one)
- Under Agentic mode, select "Agentic Tooling 2.0" from the modality dropdown
- Ensure your agent uses a reasoning model — this is required for AT 2.0 to function correctly
Agentic Tooling 2.0 needs models that can think deeply before acting — they work through problems step-by-step and remember their reasoning as they move from one tool to the next.
How Agentic Tooling 2.0 Works
How It Works
When you send a message, your agent works through it step by step:
- Think — The agent considers your request and decides what tools (if any) it needs
- Act — The agent uses one or more tools (running independent ones at the same time for speed)
- Review — The agent examines the results and decides what to do next
- Repeat — The agent keeps thinking, acting, and reviewing until the task is complete
- Report — The agent presents you with a clear, complete response
The agent remembers its thinking throughout the entire process — it doesn't forget why it started a task or what it discovered along the way, even for long-running tasks that involve many steps.
Adaptive Planning
Unlike the legacy system where a fixed plan is generated upfront and followed rigidly, AT 2.0 adapts as it goes:
- The agent creates a plan when a request involves multiple steps
- It updates progress and records key findings after each step
- It can change the plan mid-task when new discoveries change what's needed
- Key findings are preserved even in very long sessions, so nothing important is lost
Parallel Execution
When the agent identifies tasks that don't depend on each other, it runs them at the same time for faster results. For example:
- Searching your knowledge base AND the internet simultaneously
- Generating an image AND reading a file at the same time
- Delegating research to multiple specialist sub-agents concurrently
Tasks that affect shared state (like updating plans or saving memories) always run one at a time to stay consistent.
Available Tools
Every capability available in Legacy Agentic Tooling has an equivalent tool in AT 2.0. Tools are registered based on your agent's configuration — only enabled features appear.
Tool Categories
AT 2.0 organizes tools into six execution categories based on their runtime behaviour:
| Category | Execution Mode | Description |
|---|---|---|
| Parallel-Safe | Runs concurrently | Independent tools that don't share state — can execute simultaneously for speed |
| Sequential | Runs one at a time | Tools with side effects on shared state (plans, memories, delegation) — must complete before the next |
| Iterative | High repeat limit | Tools that naturally repeat many times (code execution, canvas editing) — higher consecutive-call allowance |
| Loop-Breakers | Stops the loop | Tools that end the reasoning session (handoffs, ask_user_question, submit_plan) |
| Internal | Platform-native | Built-in tools provided by the ToothFairyAI platform (RAG, search, media generation) |
| External | User-configured | Custom tools you define (APIs, MCP servers, databases, GraphQL endpoints, code templates) |
Knowledge & Search Tools
These tools search your Knowledge Hub and the internet for information. All run in parallel when called together.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
rag_search | Search your Knowledge Hub documents using semantic matching | Knowledge Hub topics configured | Internal, Parallel-Safe |
deep_rag_search | Multi-phase thorough search for hard-to-find answers in Knowledge Hub | Knowledge Hub topics configured | Internal, Parallel-Safe |
browse_knowledge_hub | Browse the Knowledge Hub structure — list topics, folders, and documents to find relevant content | Knowledge Hub topics configured | Internal, Parallel-Safe |
read_knowledge_doc | Deep-read a full Knowledge Hub document by ID (paginated) — use after RAG search when you need the complete original document, not just chunks | Knowledge Hub topics configured | Internal, Parallel-Safe |
internet_search | Search the web for current information | Internet Search enabled | Internal, Parallel-Safe |
deep_internet_search | In-depth web search with expanded coverage and deeper analysis | Internet Search enabled | Internal, Parallel-Safe |
Usage Notes:
- Start with
browse_knowledge_hubto see available topics and documents — if you find obvious matches by name, go straight toread_knowledge_doc - Only use
rag_search/deep_rag_searchwhen you need semantic matching or the hierarchy doesn't reveal the right documents - 3-strike rule: Never call search tools more than 3 times for the same topic. After 3 empty/irrelevant results, stop and disclose what you couldn't find
Media Generation Tools
Create images, videos, audio, and 3D models from text descriptions. All run in parallel when called together.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
generate_image | Create images from text descriptions (text-to-image) | Image Generation enabled | Internal, Parallel-Safe |
adapt_image | Edit an existing image with a new prompt (image-to-image) | Image Generation enabled | Internal, Parallel-Safe |
generate_video | Create videos from text descriptions | Video Generation enabled | Internal, Parallel-Safe |
generate_audio | Text-to-speech audio generation | Audio Generation enabled | Internal, Parallel-Safe |
generate_3d_model | Create 3D models from text descriptions | 3D Model Generation enabled | Internal, Parallel-Safe |
Media Analysis Tools
Analyze uploaded media files (images, videos, audio). All run in parallel when called together.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
analyze_image | Analyze an uploaded image and extract information | Media Analysis enabled | Internal, Parallel-Safe |
analyze_video | Analyze an uploaded video and extract information | Media Analysis enabled | Internal, Parallel-Safe |
analyze_audio | Analyze an uploaded audio file and extract information (transcription, speaker identification, etc.) | Media Analysis enabled | Internal, Parallel-Safe |
Code Execution & File Operations
Run Python code and manage files. Code execution and file operations can run in parallel with each other.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
execute_code | Run Python code in a sandboxed environment for data analysis, file generation, transformations, and more | Code Execution enabled | Internal, Parallel-Safe, Iterative |
read_file | Read uploaded files or files from a bound local folder (returns up to 25,000 chars; paginated with has_more / next_offset) | Files uploaded or folder bound | Internal, Parallel-Safe |
write_file | Write files to a bound local folder | Local folder bound | Internal, Parallel-Safe |
edit_file | Edit files in a bound local folder using find-and-replace operations | Local folder bound | Internal, Parallel-Safe |
create_file | Create a new file in a bound local folder | Local folder bound | Internal, Parallel-Safe |
list_files | List available files in the workspace or bound folder | Local folder bound | Internal, Parallel-Safe |
Usage Notes:
execute_codeand canvas tools (canvas_write,canvas_append,canvas_replace) have a high consecutive-call limit (1000) — they are designed for iterative workflows where you build incrementally- Read → Process → Write workflow: Call
read_file, process data withexecute_code, thenwrite_fileorcanvas_writethe results read_filereturnshas_moreandnext_offset— ifhas_moreistrue, call again withoffset=next_offsetto get the next chunk- If
has_moreisfalse, you have the complete file — do NOT re-read with different offsets
Canvas Tools
Edit collaborative Canvas documents. Canvas operations can run in parallel with other tools.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
canvas_write | Write or overwrite content in a Canvas document | Canvas enabled | Internal, Parallel-Safe, Iterative |
canvas_append | Append content to the end of a Canvas document | Canvas enabled | Internal, Parallel-Safe, Iterative |
canvas_replace | Replace specific content in a Canvas document using find-and-replace | Canvas enabled | Internal, Parallel-Safe, Iterative |
canvas_read | Read the current content of a Canvas document | Canvas enabled | Internal, Parallel-Safe |
Usage Notes:
- Canvas tools have a high consecutive-call limit (1000) — designed for incremental document building
- Two patterns: (1)
canvas_write(source='last_read_file')to stream file content to Canvas, or (2) split generated content into chunks under 3,000 chars per call
Planning Tools (Plan Mode Only)
When an agent is in Plan Mode, these tools structure the planning workflow. Planning tools are Sequential — they run one at a time to maintain plan consistency.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
create_plan | Create a new execution plan with tasks and dependencies | Plan Mode enabled | Internal, Sequential |
update_task_status | Update the status of a task in the current plan | Plan Mode enabled | Internal, Sequential |
revise_plan | Revise the current plan based on new findings | Plan Mode enabled | Internal, Sequential |
submit_plan | Submit the final plan for user approval — ends the planning session | Plan Mode enabled | Internal, Sequential, Loop-Breaker |
Plan Mode Workflow:
- EXPLORE — Use research tools (RAG, internet search, delegate to agents) to gather context
- PLAN — Synthesize findings into a structured execution plan using
create_plan - SUBMIT — Call
submit_planto present the plan for user approval
Agent Delegation
Hand off tasks to specialist sub-agents for parallel execution. Built-in specialists are always available.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
delegate_to_agent | Hand off a task to a specialist sub-agent (built-in or from your Agent Pool) | Agent Pool configured or built-in specialists available | Internal, Sequential |
Built-in Specialists:
| Specialist | What It Does Best |
|---|---|
| Researcher | Finding information — searching your knowledge base, the internet, and deep-diving into sources |
| Analyst | Processing data — running code, analysing files, generating reports and documents |
| Verifier | Checking facts — cross-referencing sources, QA, and validating results |
Critical Behaviour:
delegate_to_agentis SYNCHRONOUS and BLOCKING — the system waits for the sub-agent to finish and returns the COMPLETE response- When you receive the tool result, the delegation has already finished — there is no background processing
- Never say "delegation started", "waiting for response", "in the meantime" — the result IS the complete agent response
- If the response is empty (0 chars), the sub-agent failed or had no data — treat it as a completed (failed) call and adjust your approach
Memory Tools
Save and recall important learnings across sessions. Memory tools are Sequential to maintain consistency.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
extract_memory | Save important learnings to long-term memory for future sessions | Long-term Memory enabled | Internal, Sequential |
recall_memory | Retrieve relevant prior knowledge from long-term memory | Long-term Memory enabled | Internal, Sequential |
Usage Notes:
- Unlike Legacy Agentic Tooling where memory is saved only at the end, AT 2.0 can save and recall memories mid-task
- Call
recall_memoryat the start of a task to check for relevant past context - Call
extract_memorymid-task when you discover something important that should be preserved for future sessions
User Interaction Tools
Tools for communicating with the user during execution. These are Sequential to ensure clear, ordered communication.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
notify_user | Send a brief, visible progress update to the user during long-running tasks (e.g., "Found 3 matching documents, now analysing…") | Always available | Internal, Sequential |
ask_user_question | Ask the user for clarification when genuinely stuck — ends the reasoning session until the user responds | Always available | Internal, Sequential, Loop-Breaker |
Usage Notes:
- Use
notify_userat meaningful milestones only — phase transitions, major discoveries, or when the user benefits from knowing what's happening - Do NOT call
notify_userfor every tool — only when there's a significant state change - Use
ask_user_questiononly when you genuinely cannot proceed without clarification — not as a shortcut
Skills
Activate specialized skills for expert guidance. Skills are Sequential to ensure focused activation.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
use_skill | Activate a specialized skill for expert guidance on specific tasks | Skill configured in agent | Internal, Sequential |
Built-in Skills:
| Skill | When Your Agent Uses It |
|---|---|
| Verify Output | Before presenting results on a complex task — double-checks for accuracy and completeness |
| Step Back and Rethink | When stuck or getting poor results — takes a fresh look at the problem |
| Structure Response | When presenting findings from multiple sources — organizes the answer clearly |
Browser Automation
Automate web browser interactions for testing, scraping, and complex web workflows.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
browse_web | Automate web browser interactions (click, type, scroll, extract data) — runs in a virtual machine with persistent session | Browser + VM configured | Internal, Parallel-Safe |
Usage Notes:
- Browser sessions are persistent — the agent can maintain state across multiple calls
- Returns session summary with
final_status,total_steps, andduration_seconds
Introspection
Agent self-modification capabilities. Introspection tools are Sequential to maintain configuration consistency.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
introspect | Read or modify the agent's own configuration (instructions, tools, settings) | Introspection enabled (Retriever + Agentic mode) | Internal, Sequential |
Communication & Scheduling
Send messages and schedule future tasks. These tools are Sequential to ensure ordered delivery.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
send_email | Send emails with dynamic content | Email channel configured | Sequential |
send_sms | Send text messages | SMS channel configured | Sequential |
send_whatsapp | Send WhatsApp messages | WhatsApp channel configured | Sequential |
schedule_job | Schedule future agent tasks | Agentic mode enabled | Sequential |
External Tools (User-Configured)
Tools you define through the ToothFairyAI platform. These are Parallel-Safe by default unless they have handoff behaviour.
| Tool Type | Description | Configuration | Category |
|---|---|---|---|
| API Tools | Call external REST APIs with authentication (bearer, API key, basic, OAuth) | Configure URL, method, headers, auth | External, Parallel-Safe |
| MCP Tools | Call Model Context Protocol (MCP) servers for standardized tool integration | Configure MCP server URL and auth | External, Parallel-Safe |
| GraphQL Tools | Execute GraphQL queries and mutations with full authentication support | Configure endpoint, query/mutation, variables | External, Parallel-Safe |
| Database Tools | Execute database stored procedures with connection pooling | Configure DB connection ID, procedure name, parameters | External, Parallel-Safe |
| Code Template Tools | Run custom Python code in a sandboxed Lambda environment | Configure code template and execution environment | External, Parallel-Safe |
Authentication Support:
- Bearer token authentication
- API key authentication (header or query param)
- Basic authentication (username/password)
- OAuth 2.0 authentication
- Custom headers
Usage Notes:
- All external tool types support
staticArgs(static values merged with dynamic args) andagentFnParams(agent-level parameters) jsonPathExtractorcan extract specific data from responses using JMESPathinject_dynamic_valuesautomatically injectstfCustomerIdandtfCaseIdfrom chat context
Handoff Tools
Hand off the conversation to another agent or a human. Handoffs are Sequential and Loop-Breakers — they end the reasoning session.
| Tool | Description | Enabled When | Category |
|---|---|---|---|
handOffAgent | Hand off to another agent in your workspace | Agent Pool configured | External, Sequential, Loop-Breaker |
handedOffToHumanOnCall | Hand off to a human operator | Human handoff configured | External, Sequential, Loop-Breaker |
Usage Notes:
- Handoffs can be configured on any external tool — when the tool is called, the conversation transfers to the specified agent or human
- The reasoning loop exits immediately after a handoff is triggered
Agent Delegation — A Team of Specialists
Agentic Tooling 2.0 can hand off parts of your task to specialist sub-agents. Three built-in specialists are always available:
| Specialist | What It Does Best |
|---|---|
| Researcher | Finding information — searching your knowledge base, the internet, and deep-diving into sources |
| Analyst | Processing data — running code, analysing files, generating reports and documents |
| Verifier | Checking facts — cross-referencing sources, QA, and validating results |
When your agent has an Agent Pool configured, your own workspace specialists appear as delegation targets too. Multiple specialists can work in parallel.
How Delegation Works
- Sub-agents work in separate sessions — they don't interfere with your conversation
- Context and files are passed to the specialist automatically
- Your chat stays clean — only the final result comes back to you
- Specialists can be asked follow-up questions within the same task
Skills — Built-In Expertise
In Legacy Agentic Tooling, skills are passively available in the background. In AT 2.0, your agent actively chooses to activate a skill when it recognises the situation calls for it.
Three built-in skills are always available:
| Skill | When Your Agent Uses It |
|---|---|
| Verify Output | Before presenting results on a complex task — double-checks for accuracy and completeness |
| Step Back and Rethink | When it's stuck or getting poor results — takes a fresh look at the problem |
| Structure Response | When presenting findings from multiple sources — organises the answer clearly |
Agent-configured skills also appear as activatable tools alongside the built-ins.
Memory — Learning as It Goes
Unlike Legacy Agentic Tooling where memory is only saved at the end of a session, AT 2.0 can save and recall memories at any point during a task:
- Recall Memory — Check what it learned from past conversations at the start of a new task
- Extract Memory — Save important discoveries mid-task, so they're available in future sessions
This means your agent gets smarter over time — important findings from one task carry forward to the next.
Execution Presets — How Long Should It Work?
Agentic Tooling 2.0 offers execution presets that control how long and how hard the agent works on a task:
| Preset | Time Limit | Max Tool Uses | Best For |
|---|---|---|---|
| Short (default) | 30 min | 150 | Most tasks — balanced performance |
| Medium | 1 hour | 300 | Complex multi-step tasks |
| Long | 2 hours | 500 | Extended research and deep analysis |
| Marathon | 4 hours | 1000 | Exhaustive, long-running investigations |
You can also override individual limits while keeping a preset as the base.
Safety & Protection
AT 2.0 includes built-in safety mechanisms to keep things running smoothly:
| Protection | What It Does |
|---|---|
| Time limit | Stops if a task takes too long |
| Tool call cap | Prevents the agent from running tools indefinitely |
| Stuck detection | Notices when the agent keeps calling the same tool over and over |
| Failure circuit breaker | Stops retrying when tools keep failing |
| Duplicate detection | Catches when the agent repeats the exact same action |
When a safety limit is hit, the agent stops gracefully and reports what it has accomplished so far.
Managing Long-Running Tasks
For tasks that involve many steps and generate a lot of information, AT 2.0 automatically manages conversation length so the agent stays focused:
- Keeps recent details fresh — The most recent tool results are always available at full detail
- Summarises older context — When the conversation gets long, earlier parts are smartly summarised while key findings and decisions are preserved
- Protects important information — Key findings recorded during the task are never lost, even when the conversation is trimmed
Key insight: Your agent captures key findings as it works. These survive even in very long sessions, so the agent always knows what it has discovered so far.
Agent Configuration Properties
These properties control Agentic Tooling 2.0 behaviour. Configure them in your agent settings:
Core Activation
| Property | Default | Purpose |
|---|---|---|
useInterleavedReasoning | false | Enables Agentic Tooling 2.0 mode |
interleavedPreset | "short" | Execution preset: short, medium, long, marathon |
Fine-Tuning Overrides
| Property | Default | Purpose |
|---|---|---|
maxInterleavedIterations | From preset | Override max thinking cycles |
interleavedTimeoutSeconds | From preset | Override wall-clock timeout |
maxTotalToolCalls | From preset | Override total tool call cap |
maxConsecutiveSameTool | From preset | Override same-tool repeat limit |
maxConsecutiveFailures | From preset | Override consecutive failure circuit breaker |
maxDuplicateCalls | From preset | Override duplicate call detection |
Tool Registration
Tool availability is controlled by your existing agent feature flags — the same settings that enable capabilities in Legacy Agentic Tooling enable the corresponding tools in AT 2.0:
| Feature Flag | Tools Enabled |
|---|---|
| Knowledge Hub topics | RAG Search, Deep RAG Search |
| Internet Search | Internet Search, Deep Internet Search |
| Code Execution | Execute Code, Custom Execution Environments |
| Image Generation | Generate Image, Adapt Image |
| Video Generation | Generate Video |
| Audio Generation | Generate Audio |
| 3D Model Generation | Generate 3D Model |
| Email Channel | Send Email |
| SMS Channel | Send SMS |
| WhatsApp Channel | Send WhatsApp |
| Agentic Mode | Schedule Job |
| Introspection (Retriever + Agentic) | Introspect |
| Long-term Memory | Extract Memory, Recall Memory |
| Agent Pool | Delegate to Agent |
| Bound Local Folder | Write File, Edit File, List Files |
| Charting | Mermaid syntax guidance in system prompt |
| Browser + VM | Browse Web |
Frequently Asked Questions
Can I use Agentic Tooling 2.0 with any model?
No. AT 2.0 requires reasoning models — advanced models that can think through problems step-by-step before acting. Using it with non-reasoning models will result in degraded performance. Always pair AT 2.0 with a reasoning-capable model.
What happens if I switch from Legacy to AT 2.0 mid-conversation?
The switch takes effect on the next message. Existing conversations are not affected. The agent will begin using the expert tool selection approach on the next request.
Is Legacy Agentic Tooling going away?
Not immediately. AT 2.0 is in Beta and will supersede Legacy Agentic Tooling at a future date once it reaches full stability. Both modes are available for you to choose from today.
Does AT 2.0 support the same capabilities as Legacy?
Yes. Every capability in Legacy Agentic Tooling has an equivalent tool in AT 2.0. Feature parity is maintained — the same feature flags enable the same capabilities in both modes.
Can AT 2.0 agents delegate to other agents?
Yes. With an Agent Pool configured, AT 2.0 can hand off tasks to other workspace agents. Three built-in specialists (Researcher, Analyst, Verifier) are always available without any configuration.
Switch your Operator agent to Agentic Tooling 2.0 mode, pair it with a reasoning model, and let it tackle your most complex, long-running tasks autonomously. Remember: reasoning models only!