commit d8d5d03ef0ec2888ce8a8384fc1fd4b3ca4c6df6 Author: frmoretto <47558125+frmoretto@users.noreply.github.com> Date: Mon Feb 16 12:13:26 2026 +0100 Initial release: Edition 1.3 β€” 28 tools, 3 platforms, fully verified Claude's Hidden Toolkit documents 28 undocumented internal tools across Claude.ai's browser, desktop app, and mobile app interfaces. All parameter schemas and response formats are empirically confirmed through cross-platform testing. Co-Authored-By: Claude Opus 4.6 diff --git a/.github/ISSUE_TEMPLATE/correction.yml b/.github/ISSUE_TEMPLATE/correction.yml new file mode 100644 index 0000000..d65b33c --- /dev/null +++ b/.github/ISSUE_TEMPLATE/correction.yml @@ -0,0 +1,47 @@ +name: "πŸ› Correction" +description: Report an error or outdated information in the book +title: "[Correction] " +labels: ["correction"] +body: + - type: input + id: location + attributes: + label: Location in Book + description: Which chapter, tool card, or section? + placeholder: "e.g., Tool Card 5 (message_compose_v1), Chapter 7" + validations: + required: true + - type: textarea + id: current + attributes: + label: What the Book Currently Says + description: Quote or paraphrase the incorrect/outdated content + validations: + required: true + - type: textarea + id: observed + attributes: + label: What You Observed Instead + description: Describe the correct behavior with evidence + validations: + required: true + - type: dropdown + id: platform + attributes: + label: Platform Tested On + multiple: true + options: + - Browser (claude.ai) + - Desktop App (macOS) + - Desktop App (Windows) + - Mobile App (Android) + - Mobile App (iOS) + validations: + required: true + - type: input + id: date + attributes: + label: Date of Observation + placeholder: "2026-02-16" + validations: + required: true diff --git a/.github/ISSUE_TEMPLATE/discovery.yml b/.github/ISSUE_TEMPLATE/discovery.yml new file mode 100644 index 0000000..c1c9d1f --- /dev/null +++ b/.github/ISSUE_TEMPLATE/discovery.yml @@ -0,0 +1,65 @@ +name: "πŸ” New Tool Discovery" +description: Report a newly discovered tool or capability +title: "[Discovery] " +labels: ["discovery"] +body: + - type: input + id: tool-name + attributes: + label: Tool Name + description: The internal tool name (e.g., `reminder_create_v0`) + placeholder: tool_name_v0 + validations: + required: true + - type: dropdown + id: platform + attributes: + label: Platform + description: Where did you discover this? + multiple: true + options: + - Browser (claude.ai) + - Desktop App (macOS) + - Desktop App (Windows) + - Mobile App (Android) + - Mobile App (iOS) + validations: + required: true + - type: dropdown + id: discovery-method + attributes: + label: Discovery Method + options: + - tool_search query + - System prompt extraction + - Behavioral observation + - Error message / stack trace + - Other + validations: + required: true + - type: textarea + id: schema + attributes: + label: Parameter Schema + description: JSON schema if available (from tool_search results or system prompt) + render: json + - type: textarea + id: response + attributes: + label: Response Example + description: A real response from calling the tool + render: json + - type: textarea + id: behavior + attributes: + label: Observed Behavior + description: What does the tool do? Any gotchas, edge cases, or platform differences? + validations: + required: true + - type: input + id: date + attributes: + label: Date of Discovery + placeholder: "2026-02-16" + validations: + required: true diff --git a/.github/ISSUE_TEMPLATE/screenshot.yml b/.github/ISSUE_TEMPLATE/screenshot.yml new file mode 100644 index 0000000..d6021ba --- /dev/null +++ b/.github/ISSUE_TEMPLATE/screenshot.yml @@ -0,0 +1,48 @@ +name: "πŸ“Έ Screenshot Contribution" +description: Submit a screenshot for one of the 22 [Upcoming] figures +title: "[Screenshot] fig_XX β€” " +labels: ["screenshot"] +body: + - type: input + id: figure + attributes: + label: Figure Number + description: Which figure are you providing? (fig_01 through fig_22) + placeholder: "fig_07" + validations: + required: true + - type: dropdown + id: platform + attributes: + label: Platform Captured On + options: + - Browser (claude.ai) + - Desktop App (macOS) + - Desktop App (Windows) + - Mobile App (Android) + - Mobile App (iOS) + validations: + required: true + - type: textarea + id: description + attributes: + label: What's Shown + description: Brief description of what the screenshot captures + validations: + required: true + - type: textarea + id: screenshot + attributes: + label: Screenshot + description: Drag and drop your screenshot here. Please blur any personal information. + validations: + required: true + - type: checkboxes + id: privacy + attributes: + label: Privacy Check + options: + - label: I have blurred or removed all personal information from this screenshot + required: true + - label: I consent to this image being used in the book under CC BY 4.0 + required: true diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9524a64 --- /dev/null +++ b/.gitignore @@ -0,0 +1,25 @@ +# OS +.DS_Store +Thumbs.db +desktop.ini + +# Editors +*.swp +*.swo +*~ +.vscode/ +.idea/ + +# Temp files +*.tmp +*.bak +*.orig + +# Build artifacts +__pycache__/ +node_modules/ +*.pyc + +# Draft versions (keep only release versions in repo) +*_draft* +*_WIP* diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..f1882d4 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,46 @@ +# AGENTS.md β€” Context for AI Coding Agents + +## What This Repo Is + +A technical book ("Claude's Hidden Toolkit") documenting 28 undocumented internal tools in Claude.ai's consumer interfaces. Fully reverse-engineered through systematic testing across browser, desktop app, and mobile app. + +## File Roles + +| File | Role | Editable? | +|------|------|-----------| +| `Claude_Hidden_Toolkit.md` | Source of truth | Yes β€” all content changes here | +| `README.md` | GitHub landing page | Yes | +| `LICENSE` | CC BY 4.0 | No | + +## Domain Knowledge + +- **28 tools** documented with confirmed JSON schemas +- **3 platforms** with different tool inventories (browser: 21 tools, desktop: 22+32 MCP, mobile: 20+11 deferred) +- **Tool cards** in the Technical Annex follow a strict template (see Appendix C in the book) +- **Figures** are numbered sequentially fig_01 through fig_22 β€” all currently marked [Upcoming] pending screenshot capture +- **Response formats** are all empirically confirmed β€” no inferred markers remain + +## Conventions + +- Tool names in backticks: `web_search`, `event_create_v0` +- Platform tags on every claim: "Mobile App only", "Browser + Desktop only", "All" +- Version suffixes: `_v0` (initial/experimental), `_v1` (breaking upgrade) +- Confirmed vs unverified clearly marked β€” never speculate + +## Architecture Context + +The book documents a two-tier tool loading system: +- **Always-loaded tools**: injected into every conversation context (~17-22 depending on platform) +- **Deferred tools**: discovered at runtime via `tool_search` (mobile only, 11 consumer tools) +- **MCP tools**: discovered via `tool_search` on desktop only (32 integration tools) + +The calendar system has a dual-layer architecture where Projects use MCP Connector tools with email-based IDs, while standard mobile chats use deferred consumer tools with numeric string IDs. The two layers are incompatible. + +## Quality Gates + +Before any content change: +1. Has the claim been tested on the relevant platform(s)? +2. Is the platform availability clearly stated? +3. Does the tool card follow the template structure? +4. Are figure numbers sequential with no gaps? +5. Is the response format marked as confirmed or unverified? diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..829d66c --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,68 @@ +# Changelog + +All notable changes to Claude's Hidden Toolkit are documented here. + +Format follows [Keep a Changelog](https://keepachangelog.com/). Editions are tagged by version. + +## [1.3] β€” 2026-02-16 + +### Added +- **Platform Architecture section** (new Chapter 2.5) β€” tool inventory matrix across browser (21 tools), desktop app (22+32 MCP), and mobile app (20+11 deferred) +- **3 new tool cards**: `weather_fetch` (Card 26), `recipe_display_v0` (Card 27), `end_conversation` (Card 28) +- Platform-exclusive tools table showing which tools exist where +- Session instability warning (switching clients changes available tools) +- Fallback behavior documentation for each platform gap +- Settings & Connectors reference integrated into appendix +- 9 new figure placeholders (fig_14 through fig_22) + +### Changed +- **Chapter 10 (Discovery Log)**: added mobile-only environment note β€” the discovery log was produced on mobile and is not reproducible on browser or desktop +- **Chapter 2 (Architecture)**: rewritten to reflect three platform configurations instead of a single binary always-loaded/deferred model +- **Card 5 (message_compose_v1)**: corrected primary button to "Send via Gmail", documented dropdown with "Open in Mail", added no-recipient-field note +- **Card 4 (ask_user_input_v0)**: added "Something else" free-text option, Skip button, keyboard shortcuts, selection counter, drag handles, pagination +- **Cards 17/18 (places)**: added markers mode sidebar details, itinerary mode routing, "Open route" Google Maps behavior, confirmation dialog inconsistency +- **Card 6 (alarm_create_v0)**: confirmed mobile-only, added widget description with Italian locale, removed web/desktop speculation +- **Card 7 (timer_create_v0)**: confirmed mobile-only, added widget description +- **Card 1 (user_time_v0)**: added platform behavior differences (mobile returns exact time, desktop/browser states system date only) +- **Card 3 (user_location_v0)**: confirmed mobile-only, documented two-layer permission system (Claude app + Android OS) +- **Card 10 (chart_display_v0)**: confirmed mobile-only deferred, added app crash warning +- **Card 25 (tool_search)**: major rewrite β€” browser has no tool_search, desktop finds MCP only, mobile finds consumer tools +- **Cards 8–13 (Calendar suite)**: added mobile-only deferred status, Google Calendar connection requirement +- **Appendix A**: corrected availability matrix to reflect cross-platform testing results +- All response formats upgraded from *(inferred)* to empirically confirmed +- Figure numbering made sequential (fig_01 through fig_22, eliminated fig_14b) + +### Removed +- All *(inferred)* response format markers β€” every schema now confirmed through testing +- Speculative web/desktop availability claims for mobile-only tools +- Screenshot capture instructions from figure placeholders + +## [1.2] β€” 2026-02-13 + +### Added +- Technical Annex with 25 detailed tool cards +- Appendix C: Tool Template for New Discoveries +- Figure placeholders with capture instructions +- Companion GitHub repository + +### Changed +- Expanded Chapter 10 Discovery Log with full query-by-query enumeration +- Added environment note about tool_search behavior in Projects vs standard chats + +## [1.1] β€” 2026-02-10 + +### Added +- Complete parameter schemas for all 25 tools +- Cross-reference with prior research (Khemani, Willison, Adversa AI, Viticci) +- Discovery methodology (Appendix B) + +### Changed +- Restructured from flat tool list to chapter-based organization + +## [1.0] β€” 2026-02-07 + +### Added +- Initial release documenting 25 internal tools +- Two-tier architecture analysis (always-loaded vs deferred) +- tool_search enumeration methodology +- Availability matrix (Appendix A) diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..a865eb5 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,27 @@ +cff-version: 1.2.0 +message: "If you reference this work, please cite it as below." +title: "Claude's Hidden Toolkit: The Definitive Guide to Claude.ai's Undocumented Internal Tools" +type: software +authors: + - family-names: "Marinoni Moretto" + given-names: "Francesco" + orcid: "" +version: "1.3" +date-released: "2026-02-16" +url: "https://github.com/n1-ai/claude-hidden-toolkit" +license: "CC-BY-4.0" +keywords: + - claude + - anthropic + - ai-tools + - reverse-engineering + - internal-tools + - tool-use + - model-context-protocol + - claude-ai +abstract: >- + Comprehensive reverse-engineering documentation of 28 undocumented internal + tools in Claude.ai's consumer interfaces (browser, desktop app, mobile app). + Covers complete parameter schemas, confirmed response formats, platform-specific + behavior differences, and a three-tier tool loading architecture across three + client surfaces. Based on 35+ manual tests with empirical verification. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..537d437 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,49 @@ +# CLAUDE.md β€” Instructions for Claude Code + +## Project Overview + +This is "Claude's Hidden Toolkit" β€” a living technical book documenting Claude.ai's undocumented internal tools. The book reverse-engineers 28 tools across three platforms (browser, desktop app, mobile app) with confirmed schemas, response formats, and behavioral patterns. + +## Repository Structure + +``` +Claude_Hidden_Toolkit.md # The book (source of truth β€” all edits here) +README.md # GitHub landing page +CLAUDE.md # You are here +AGENTS.md # General AI agent context +CHANGELOG.md # Edition history with detailed changes +CITATION.cff # Academic citation metadata +CONTRIBUTING.md # Contribution guidelines +SECURITY.md # Responsible disclosure policy +LICENSE # CC BY 4.0 +``` + +## Key Rules + +1. **The .md file is the source of truth.** All content edits happen here. +2. **All tool claims must be empirically verified.** No speculative schemas. If you haven't tested it, mark it as unverified. +3. **Platform matters.** Every tool claim must specify which platform(s) it applies to: browser, desktop app, mobile app, or all. +4. **Figure numbering is sequential** (fig_01 through fig_22). If adding figures, continue the sequence. Never use letter suffixes (e.g., fig_14b). +5. **Tool cards follow a strict template.** See Appendix C in the book for the template. Every card needs: quick facts table, overview, parameters table, example call with JSON, "When Claude Uses It" table, "Watch Out" section, and platform availability table. + +## Writing Style + +- Technical but accessible β€” assume the reader is a developer or power user +- No hedging without evidence β€” say "confirmed" or "not tested", never "probably" +- Use backtick formatting for all tool names, parameter names, and code +- Tables over bullet lists for structured comparisons +- Blockquotes (>) for figure placeholders and warnings + +## Tool Naming Conventions + +- Always-loaded tools: `web_search`, `memory_user_edits`, etc. +- Deferred tools (mobile only): `user_time_v0`, `alarm_create_v0`, etc. +- Version suffixes: `_v0` = initial, `_v1` = breaking change upgrade +- Unversioned tools are considered stable + +## What Not To Do + +- Don't add tools without cross-platform verification +- Don't change the figure numbering scheme without renumbering all references +- Don't remove the [Upcoming] tags on figures β€” they indicate screenshots pending capture +- Don't merge the .md living repository links with personal GitHub links β€” they serve different purposes diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..ccf9e7a --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,76 @@ +# Contributing to Claude's Hidden Toolkit + +Thanks for your interest in contributing! This project documents Claude.ai's undocumented internal tools β€” every contribution helps the community understand what's really happening under the hood. + +## How to Contribute + +### Reporting New Tools or Changes + +If you've discovered a new tool, a schema change, or platform-specific behavior not covered in the book: + +1. **Open an Issue** with the label `discovery` +2. Include: + - Tool name (exact internal name if known) + - Platform tested on (browser / desktop app / mobile app / iOS / Android) + - How you discovered it (e.g., `tool_search` query, system prompt extraction, behavioral observation) + - Parameter schema if available (JSON) + - Response format with a real example + - Any gotchas or edge cases observed + +### Correcting Existing Documentation + +If something in the book is wrong or outdated: + +1. **Open an Issue** with the label `correction` +2. Include: + - Which tool card or chapter section is affected + - What the book currently says + - What you observed instead + - Platform and date of observation + +### Submitting a Pull Request + +For direct content changes: + +1. Fork the repo +2. Edit `Claude_Hidden_Toolkit.md` only β€” this is the source of truth +3. Follow the existing formatting conventions (see below) +4. Submit a PR with a clear description of what changed and how it was verified + +## Formatting Conventions + +- **Tool names** in backticks: `web_search`, `event_create_v0` +- **Platform availability** stated on every claim +- **Tool cards** follow the template in Appendix C β€” don't freestyle the structure +- **Figures** are numbered sequentially (fig_01 through fig_22+). Continue the sequence; never reuse or skip numbers +- **Response formats** marked as confirmed with real output. If you can't confirm, note it explicitly +- **Tables** for structured comparisons, not bullet lists + +## Verification Standard + +This project has a strict empirical standard. We don't document tools based on speculation, hearsay, or what "should" work. Every claim must be: + +- **Tested** on at least one platform with a real Claude.ai session +- **Reproducible** β€” another user should be able to trigger the same behavior +- **Platform-tagged** β€” specifying exactly where it works and where it doesn't + +If you've observed something but can't fully verify it, open an Issue rather than a PR. The community can help confirm. + +## What We're Looking For + +High-value contributions include: + +- **iOS-specific tools** (Reminders suite, Siri integration) β€” we have limited iOS testing coverage +- **Screenshot captures** for the 22 figures currently marked [Upcoming] +- **Cross-platform verification** of existing tool cards on platforms we haven't tested +- **New deferred tools** discovered via `tool_search` sweeps +- **Schema changes** from Anthropic updates that break or modify existing tools +- **MCP Connector behavior** differences between Projects and standard chats + +## Code of Conduct + +Be respectful, constructive, and evidence-based. This is a technical documentation project β€” claims need proof, disagreements are settled by testing, and everyone's contributions are valued. + +## License + +By contributing, you agree that your contributions will be licensed under [CC BY 4.0](LICENSE), the same license as the rest of the project. diff --git a/Claude_Hidden_Toolkit.md b/Claude_Hidden_Toolkit.md new file mode 100644 index 0000000..e28092e --- /dev/null +++ b/Claude_Hidden_Toolkit.md @@ -0,0 +1,2931 @@ +# Claude's Hidden Toolkit + +**The Definitive Guide to Claude.ai's Undocumented Internal Tools** + +*28 tools. Zero official documentation. Fully reverse-engineered.* + +**Francesco Marinoni Moretto** β€” AI Practice & Community Lead, N1AI + +Edition 1.3 β€” February 2026 Β· Based on systematic research with Claude Opus 4.6 + +--- + +Β© 2026 Francesco Marinoni Moretto. Published by N1AI. Licensed under CC BY 4.0. +You are free to share and adapt this work with attribution. + +This book documents tools observed in Claude.ai as of February 2026. Anthropic may change, rename, or remove these tools at any time. This work is independent and not affiliated with Anthropic. + +Living repository: [github.com/n1-ai/claude-hidden-toolkit](https://github.com/n1-ai/claude-hidden-toolkit) + +Author: [linkedin.com/in/francesco-moretto](https://www.linkedin.com/in/francesco-moretto) + +--- + + +## About the Author + +Francesco Marinoni Moretto is AI Practice & Community Lead at N1AI, where he bridges the gap between AI capabilities and practical business adoption. An 18-year community builder turned AI systems architect, he brings a pattern of discovering powerful tools and building adoption communities across European markets β€” from Italy's first CiviCRM evangelist in 2008 to the European AI developer circuit today. His published work includes Hardstop (the first fail-closed safety plugin for Claude agentic tools), Clarity Gate (epistemic verification for RAG systems), Stream Coding (a documentation-first development methodology), and the definitive guide to Claude's `memory_user_edits` system. This book grew from a simple observation: Claude.ai ships with 28+ internal tools, and almost none of them are documented. Full bio at the end of this book. + +[linkedin.com/in/francesco-moretto](https://www.linkedin.com/in/francesco-moretto) Β· [github.com/frmoretto](https://github.com/frmoretto) + +## About N1AI + +N1AI is a community-driven AI consultancy that puts human needs first. They help businesses discover, plan, and implement AI solutions β€” from initial discovery through strategy, execution, and team training. Their community connects business owners, developers, and AI enthusiasts who are making AI work in the real world. N1AI partners with Anthropic, OpenAI, and Google, and leads with H.E.A.R.T.: Human first, Entrepreneurship, Action, Results, and Transparency. + +[n1ai.co](https://www.n1ai.co) Β· [Community](https://www.n1ai.co/community/) + +--- + +## Contents + +| Chapter | Title | Topics | +| --- | --- | --- | +| [1](#chapter-1--why-this-book-exists) | Why This Book Exists | The documentation gap Β· Who this is for Β· How to use this book | +| [2](#chapter-2--the-architecture-of-claudeais-tool-system) | The Architecture of Claude.ai's Tool System | Always-loaded vs. deferred tools Β· Platform architecture Β· The discovery mechanism Β· Versioning | +| [3](#chapter-3--context-tools-time--location) | Context Tools: Time & Location | `user_time_v0` Β· `user_location_v0` Β· How Claude knows where and when you are | +| [4](#chapter-4--the-interaction-layer-widgets--message-drafting) | The Interaction Layer: Widgets & Message Drafting | `ask_user_input_v0` Β· `message_compose_v1` Β· Beyond plain text | +| [5](#chapter-5--visualization-inline-charts) | Visualization: Inline Charts | `chart_display_v0` Β· When to use charts vs. artifacts Β· Limitations | +| [6](#chapter-6--calendar--device-integration) | Calendar & Device Integration | 6 calendar tools Β· `alarm_create_v0` Β· `timer_create_v0` Β· Mobile-native features | +| [7](#chapter-7--search--data-tools) | Search & Data Tools | `web_search` Β· `web_fetch` Β· `image_search` Β· `places_search` Β· `places_map_display_v0` Β· `fetch_sports_data` Β· Google Drive tools Β· `weather_fetch` Β· `recipe_display_v0` | +| [8](#chapter-8--the-memory-stack-how-claude-remembers-you) | The Memory Stack: How Claude Remembers You | `memory_user_edits` Β· `conversation_search` Β· `recent_chats` Β· The three-layer model Β· Memory settings | +| [9](#chapter-9--computer-use-files-code--artifacts) | Computer Use: Files, Code & Artifacts | `bash_tool` Β· `view` Β· `create_file` Β· `str_replace` Β· `present_files` Β· The skill system Β· Execution settings | +| [10](#chapter-10--the-meta-tool-tool_search) | The Meta-Tool: tool_search | How to discover tools yourself Β· Enumeration methodology Β· Platform-dependent behavior Β· What might be hiding | +| [11](#chapter-11--the-complete-tool-reference) | The Complete Tool Reference | Every tool Β· Every parameter Β· Copy-paste ready | +| [12](#chapter-12--what-comes-next) | What Comes Next | The MCP convergence Β· Building on top of hidden tools | +| [A](#appendix-a--availability-matrix) | Availability Matrix | | +| [B](#appendix-b--discovery-methodology) | Discovery Methodology | | +| [C](#appendix-c--tool-template-for-new-discoveries) | Tool Template for New Discoveries | | +| [D](#appendix-d--settings--connectors-reference) | Settings & Connectors Reference | | +| | [Technical Annex](#technical-annex--detailed-tool-cards) | 28 detailed tool cards with JSON examples | + +### Figures + +| Figure | Description | Location | +| --- | --- | --- | +| `fig_01` | `tool_search` discovery flow | [Chapter 2](#chapter-2--the-architecture-of-claudeais-tool-system) | +| `fig_02` | `user_time_v0` response in chat | [Chapter 3](#chapter-3--context-tools-time--location) | +| `fig_03` | `user_time_v0` expanded tool call (mobile) | [Chapter 3](#chapter-3--context-tools-time--location) | +| `fig_04` | Browser geolocation permission prompt | [Chapter 3](#chapter-3--context-tools-time--location) | +| `fig_05` | Location widget + two permission layers (mobile) | [Chapter 3](#chapter-3--context-tools-time--location) | +| `fig_06` | `ask_user_input_v0` three widget types (single_select, multi_select, rank_priorities) | [Chapter 4](#chapter-4--the-interaction-layer-widgets--message-drafting) | +| `fig_07` | `message_compose_v1` email card with Gmail dropdown | [Chapter 4](#chapter-4--the-interaction-layer-widgets--message-drafting) | +| `fig_08` | Inline chart from `chart_display_v0` | [Chapter 5](#chapter-5--visualization-inline-charts) | +| `fig_09` | Calendar event creation confirmation | [Chapter 6](#chapter-6--calendar--device-integration) | +| `fig_10` | Alarm widget (mobile, Italian locale) | [Chapter 6](#chapter-6--calendar--device-integration) | +| `fig_11` | Timer widget (mobile) | [Chapter 6](#chapter-6--calendar--device-integration) | +| `fig_12` | Weather widget (browser + desktop comparison) | [Chapter 7](#chapter-7--search--data-tools) | +| `fig_13` | Recipe widget β€” browser + desktop comparison | [Chapter 7](#chapter-7--search--data-tools) | +| `fig_14` | Recipe cooking mode β€” step-by-step + timer states | [Chapter 7](#chapter-7--search--data-tools) | +| `fig_15` | Places markers mode β€” overview + detail popup | [Chapter 7](#chapter-7--search--data-tools) | +| `fig_16` | Places itinerary mode with walking route | [Chapter 7](#chapter-7--search--data-tools) | +| `fig_17` | Sports standings from `fetch_sports_data` | [Chapter 7](#chapter-7--search--data-tools) | +| `fig_18` | `memory_user_edits` view output | [Chapter 8](#chapter-8--the-memory-stack-how-claude-remembers-you) | +| `fig_19` | File creation and `present_files` download card | [Chapter 9](#chapter-9--computer-use-files-code--artifacts) | +| `fig_20` | Raw `tool_search` results | [Chapter 10](#chapter-10--the-meta-tool-tool_search) | +| `fig_21` | Settings β†’ Connectors page | [Appendix D](#appendix-d--settings--connectors-reference) | +| `fig_22` | Settings β†’ Capabilities (Artifacts + Code + Memory + Skills) | [Appendix D](#appendix-d--settings--connectors-reference) | + +--- + +## Chapter 1 β€” Why This Book Exists + +Claude.ai is not just a chatbot. Beneath the conversational interface lies an orchestration engine with 28 distinct tools β€” capabilities that let Claude check the time, search your calendar, render interactive charts, draft emails with native app integration, find nearby restaurants, display them on a map, show weather forecasts, walk you through recipes step by step, and even set alarms on your phone. + +> *Almost none of this is documented.* + +Anthropic's official documentation covers the API: how developers can build with Claude using tools they define themselves. But the consumer product β€” claude.ai β€” ships with a rich, evolving toolkit that exists in a documentation void. Support articles describe what users can do in consumer-friendly language ("set alarms," "find nearby places") without ever revealing the internal tool names, parameter schemas, response formats, or behavioral patterns. + +This book fills that void. It is the result of systematic reverse-engineering: probing Claude's tool discovery mechanism, capturing every discoverable tool, testing their parameters and responses across three platforms (browser, desktop app, mobile app), and documenting the results in a format that is both readable and technically precise. + +### The Documentation Gap + +A comprehensive search across GitHub, Reddit, LinkedIn, Twitter/X, YouTube, and the broader web reveals that this territory is almost entirely unexplored. Of the 28 tools documented in this book, only two β€” `conversation_search` and `recent_chats` β€” have been previously reverse-engineered with full schemas published (by Shlok Khemani, September 2025). One additional tool, `message_compose_v1`, was named in an Adversa AI security research paper. The remaining tools have zero public documentation by their internal names. + + +The following table shows the documentation status of every tool at the time of writing: + +| Tool | Public Documentation Status | +| --- | --- | +| `conversation_search` | Fully documented (Khemani, Sept 2025) | +| `recent_chats` | Fully documented (Khemani, Sept 2025) | +| `message_compose_v1` | Named once (Adversa AI security paper) | +| `user_time_v0` | Zero public results by internal name | +| `user_location_v0` | Zero public results by internal name | +| `chart_display_v0` | Zero public results by internal name | +| `ask_user_input_v0` | Zero public results by internal name | +| `weather_fetch` | Zero public results by internal name | +| `recipe_display_v0` | Zero public results by internal name | +| `end_conversation` | Zero public results by internal name | +| `alarm_create_v0` | Feature documented by Anthropic, internal name unknown publicly | +| `timer_create_v0` | Feature documented by Anthropic, internal name unknown publicly | +| Calendar suite (6 tools) | Feature documented by Anthropic, internal names unknown publicly | +| `places_search` | Zero public results by internal name | +| `places_map_display_v0` | Zero public results by internal name | +| `fetch_sports_data` | Zero public results by internal name | +| `google_drive_search` / `google_drive_fetch` | Zero public results by internal name | +| `tool_search` | Zero public results by internal name | + +Credit to the prior researchers: Shlok Khemani (memory tools), Simon Willison (system prompt analysis), Adversa AI (security research), Federico Viticci / MacStories (iOS tools and `_v0` naming convention discovery). + + +### Who This Book Is For + +This book serves three audiences. **Power users** will learn exactly what to say to trigger hidden capabilities β€” from inline charts to interactive choice widgets β€” and understand when Claude uses these tools automatically. **Developers** building on the Anthropic API will see what the consumer product does that the API doesn't, giving them a blueprint for what to build with MCP or custom tools. **AI researchers** will find a documented case study of how a production AI system's tool architecture works β€” the design tradeoffs, the deferred loading strategy, the platform-specific behaviors, and the behavioral patterns. + +### How to Use This Book + +Chapters 1–2 provide context and architecture. Chapters 3–9 are deep dives into each tool category, organized by function. Chapter 10 covers the meta-tool that makes discovery possible. Chapter 11 is a complete reference β€” every tool, every parameter β€” designed for quick lookup. Chapter 12 looks ahead. The Technical Annex provides a detailed card for every tool with JSON call examples. + +This book has a companion GitHub repository at [github.com/n1-ai/claude-hidden-toolkit](https://github.com/n1-ai/claude-hidden-toolkit) that is updated as tools change. Think of this book as Edition 1.3 β€” a snapshot of the tool ecosystem as of February 2026 β€” and the repository as the living document. + +**A note on accuracy:** Parameter schemas for deferred tools were captured directly from `tool_search` results and are exact. Always-loaded tool schemas were extracted from Claude's system-level tool definitions. All response formats have been empirically confirmed through cross-platform testing β€” no *(inferred)* markers remain in this edition. All claims except one explicitly marked parameter have been tested through both automated and manual verification across three platforms (browser, desktop app, mobile app) β€” see Appendix B for the full methodology. + +**What changed in v1.3:** This edition adds cross-platform testing results that fundamentally change the architecture picture. Three new tools (`weather_fetch`, `recipe_display_v0`, `end_conversation`) are documented, 15 existing tool cards are updated with platform-specific corrections, and a new Settings & Connectors reference is added as Appendix D. The platform architecture section in Chapter 2 is entirely new. + +--- + +## Chapter 2 β€” The Architecture of Claude.ai's Tool System + +Understanding how Claude.ai's tools work requires understanding two fundamental architectural distinctions: not all tools are created equal, and not all tools are available on all platforms. + +### Two Classes of Tools + +Claude.ai's tools fall into two categories: **always-loaded** tools that are available from the start of every conversation, and **deferred** tools that are discovered and loaded on demand. + +Always-loaded tools include the workhorses: `web_search`, `web_fetch`, `image_search`, `places_search`, `places_map_display_v0`, `fetch_sports_data`, `google_drive_search`, `google_drive_fetch`, `memory_user_edits`, `conversation_search`, `recent_chats`, `ask_user_input_v0`, `message_compose_v1`, `weather_fetch`, `recipe_display_v0`, `end_conversation`, and the computer use tools. These are injected into every conversation's context from the start. + +Deferred tools include: `user_time_v0`, `user_location_v0`, `chart_display_v0`, `alarm_create_v0`, `timer_create_v0`, and the calendar suite. These are not loaded until Claude determines they're needed β€” either by recognizing a relevant user request or by explicitly searching for them using the meta-tool `tool_search`. + +#### Why Deferred Loading? + +Context window efficiency. Every tool definition consumes tokens β€” roughly 200–800 tokens depending on parameter complexity. By deferring 11 tools that are only needed in specific scenarios (time queries, alarm setting, calendar management), Claude.ai saves an estimated 3,000–5,000 tokens per conversation, keeping its baseline context lean. The trade-off is a slight latency on first use β€” the tool must be discovered before it can be called. Once loaded, deferred tools remain available for the rest of the conversation. + + +### Platform Architecture: Three Surfaces, Three Tool Sets + +This is the single most important finding from cross-platform testing: **Claude.ai is not one product with one tool set β€” it is three distinct surfaces with different tool inventories.** The browser (claude.ai), the desktop app, and the mobile app each present a different configuration of tools to the model. + +#### Platform Inventory + +| Platform | Always-Loaded Tools | `tool_search` Present? | Deferred Tools Available | +|----------|---------------------|----------------------|-------------------------| +| Browser (claude.ai) | 21 | No | None | +| Desktop App | 22 | Yes (MCP tools only) | 32 MCP tools (e.g., Chrome + Filesystem) | +| Mobile App | 20 | Yes (consumer tools) | 11 consumer deferred tools | + +The implications are significant. On the **browser**, what you see is what you get β€” there are 21 always-loaded tools and no deferred loading system at all. `tool_search` does not exist. On the **desktop app**, `tool_search` exists but only discovers MCP integration tools (such as Claude in Chrome and Filesystem tools) β€” it returns up to 32 integration tools rather than consumer deferred tools. On the **mobile app**, `tool_search` discovers the 11 consumer deferred tools documented in this book. + +#### Platform-Exclusive Tools + +Some tools exist on only a subset of platforms: + +| Tool | Browser | Desktop App | Mobile App | +|------|---------|-------------|------------| +| `weather_fetch` | βœ… | βœ… | ❌ | +| `recipe_display_v0` | βœ… | βœ… | ❌ | +| `tool_search` | ❌ | βœ… (MCP only) | βœ… (consumer) | +| 11 consumer deferred tools | ❌ | ❌ | βœ… | + +This means, for example, that `alarm_create_v0`, `timer_create_v0`, `user_time_v0`, `user_location_v0`, `chart_display_v0`, and the calendar suite are only available as deferred tools on the mobile app. On browser and desktop, these capabilities either don't exist or Claude falls back to alternative approaches. + +#### Session Instability Warning + +Switching between clients mid-conversation changes your available tools. The tool set is **client-bound, not conversation-bound**. If you start a conversation on mobile (where `alarm_create_v0` is available) and continue it on the browser (where it isn't), the alarm tool disappears. Claude does not warn you about this β€” it simply loses access to tools that were available moments earlier. + +#### Fallback Behavior + +When you request a capability that doesn't exist on your current platform, Claude falls back gracefully rather than failing: + +- **Weather** (mobile): uses `web_search` instead of `weather_fetch` β€” returns text-only weather data, no interactive widget +- **Charts** (browser/desktop): creates a React artifact with Recharts instead of `chart_display_v0` β€” opens in the artifact sidebar rather than inline. Note: even on mobile where `chart_display_v0` exists, it currently crashes the app on all chart types (see Chapter 5) β€” making the artifact fallback the only working option on any platform +- **Recipes** (mobile): returns plain text recipe in conversation β€” no interactive widget, no cooking mode +- **Alarms/timers** (browser/desktop): suggests using Google timer, a voice assistant, or offers to create an artifact-based timer +- **Location** (browser/desktop): `user_location_v0` is absent; Claude states it cannot access local time/location and asks manually + +### The Versioning Convention + +Internal tools follow a `tool_name_v0` / `v1` naming convention. The `v0` suffix indicates an initial or experimental release. When a tool evolves with breaking changes, the version increments. The clearest example is the calendar tool: `event_create_v0` creates a single event, while `event_create_v1` accepts a batch array. Both coexist, suggesting Anthropic maintains backward compatibility rather than deprecating immediately. + +Not all tools carry version suffixes. `web_search`, `web_fetch`, and `fetch_sports_data` are unversioned, which may indicate they are considered stable or that they predate the versioning convention. + +### The Discovery Mechanism + +The most architecturally interesting tool is `tool_search` β€” a meta-tool whose sole purpose is discovering other tools. It accepts a keyword query and returns matching tool names with their parameter schemas. This is how Claude.ai implements deferred loading: when a user asks "What time is it?", Claude can search for time-related tools, discover `user_time_v0`, load it, and call it β€” all within a single response. + +**Critical platform caveat:** As documented above, `tool_search` behaves fundamentally differently across platforms. The discovery methodology in Chapter 10 was conducted on the mobile app and is only reproducible there. On the browser, `tool_search` does not exist. On the desktop app, it returns MCP integration tools instead of consumer deferred tools. + +Chapter 10 covers `tool_search` in detail, including the keyword sweeps used to enumerate the full toolkit for this book. + +> **πŸ“Έ IMAGE: `fig_01_tool_search_flow.png`** +> Screenshot showing Claude calling `tool_search` in real time. +> *[Upcoming]* + +### Platform Availability + +A critical finding: these tools exist only within Claude.ai's consumer interfaces (web, mobile app, desktop app). They are **not** available through the Anthropic API, Claude Code, or any third-party integration. Developers using the API must implement equivalent functionality themselves. The full availability matrix is in Appendix A. + +--- + +## Chapter 3 β€” Context Tools: Time & Location + +Two tools give Claude awareness of the user's physical context: where they are and when they are. These are foundational β€” other tools depend on them for timezone handling and location-biased searches. + +### `user_time_v0` + +The simplest tool in the entire toolkit. Zero parameters, one response field. Call it and get the current time in the user's timezone. + +**Platform:** Mobile App only (deferred via `tool_search`). On browser and desktop, this tool is absent β€” Claude states the system date from its context but acknowledges it cannot access local time. + +**Parameters:** None + +**Response:** + +```json +{"current_time": "2026-02-14T13:04:23.428731+01:00"} +``` + +The response is ISO 8601 with microsecond precision and the user's UTC offset. The timezone is detected from the user's browser or device settings β€” not from IP geolocation. This means VPN users still get their device's configured timezone, and manual timezone overrides are respected. + +Claude uses this tool proactively when time context improves a response: scheduling questions, timezone conversions, day-of-week awareness, and timestamping activities. It also serves as a prerequisite for calendar operations, where ISO 8601 timestamps with correct offsets are required. + +> **πŸ“Έ IMAGE: `fig_02_user_time_response.png`** +> Screenshot of Claude responding with the current time. +> *[Upcoming]* + +> **πŸ“Έ IMAGE: `fig_03_user_time_expanded.png`** +> Screenshot of the expanded `user_time_v0` tool call on mobile, showing the raw tool invocation and response. +> *[Upcoming]* + +### `user_location_v0` + +The only tool that requires explicit user permission. When called, the device displays a geolocation prompt. If granted, it returns coordinates; if denied, Claude falls back gracefully. + +**Platform:** Mobile App only (deferred via `tool_search`). On browser and desktop, this tool is absent β€” Claude cannot determine user location and will ask manually. + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `accuracy` | string | Yes | `"low"` (city-level) or `"high"` (GPS-level) | + +This tool is most commonly used as a precursor to `places_search` β€” get the user's location, then search for nearby businesses using the coordinates as a bias. Claude appears cautious about calling it proactively; it is typically triggered by location-implying language ("near me," "nearby," "around here"). + +**Response** *(confirmed)*: + +```json +{ + "status": "success", + "latitude": 45.4707004, + "longitude": 9.1248245, + "geocoded": { + "address": "Via Example 15", + "administrative_area": "Lombardia", + "country": "Italia", + "locality": "Milano", + "name": "15", + "postal_code": "20100" + } +} +``` + +Key findings from testing: the `accuracy` parameter ("high" vs "low") produced **no meaningful difference** in the response β€” coordinates were nearly identical in both cases. The `geocoded` object provides a full reverse-geocoded address that the coordinates alone don't convey. There is **no** `accuracy_meters` field in the response. + +#### Two-Layer Permissions (Mobile) + +On mobile, location access involves two permission layers: + +1. **Claude app permission:** A native prompt asking "Allow once / Allow always / Cancel" (localized β€” e.g., "Consenti una volta / Consenti sempre / Annulla" on Italian devices) +2. **Android OS permission:** System-level prompt for Exact vs. Approximate location, with usage scope selection + +Both must be granted for the tool to return precise coordinates. The result widget displays a pin icon, full street address, and a Google Maps thumbnail. + +> **πŸ“Έ IMAGE: `fig_04_location_permission.png`** +> Screenshot showing the browser's geolocation permission prompt triggered by Claude. +> *[Upcoming]* + +> **πŸ“Έ IMAGE: `fig_05_location_mobile.png`** +> Screenshot showing the mobile location widget with pin icon and street address, plus both permission layers (Claude app + Android OS). +> *[Upcoming]* + +### Context Tools: Side by Side + +| | `user_time_v0` | `user_location_v0` | +| --- | --- | --- | +| Permission required | No | Yes (device prompt β€” two layers on Android) | +| Parameters | 0 | 1 (`accuracy` β€” but no observable effect in testing) | +| Platform | Mobile only (deferred) | Mobile only (deferred) | +| Response | ISO 8601 timestamp | Coordinates + reverse-geocoded address | +| Platform variance | Mobile: exact time; Browser/Desktop: system date only | Mobile: GPS + geocoded; Browser/Desktop: absent | +| Feeds into | Calendar, alarm, timer tools | `places_search`, weather, distance queries | + +--- + +## Chapter 4 β€” The Interaction Layer: Widgets & Message Drafting + +Two tools transform Claude from a text-in, text-out system into something with actual UI capabilities. These are arguably the most novel tools in the toolkit β€” they render interactive elements that users can click, tap, and manipulate. + +### `ask_user_input_v0`: Interactive Choice Widgets + +Instead of asking questions in plain text, Claude can present structured choices as clickable buttons, multi-select chips, or drag-and-drop ranking interfaces. The widget renders at the bottom of the chat, below Claude's text response. + +Three question types are supported: `single_select` (pick one), `multi_select` (pick one or more), and `rank_priorities` (drag to reorder). Each call supports 1–3 questions with 2–4 options each. + +The design implications are significant. A consulting intake that would take 5 back-and-forth messages can be compressed into a single interaction: + +```json +{ + "questions": [ + {"question": "What's your main goal?", "type": "single_select", + "options": ["Increase revenue", "Cut costs", "Enter new market", "Fix operations"]}, + {"question": "Timeline?", "type": "single_select", + "options": ["This quarter", "This year", "2+ years"]} + ] +} +``` + +Two questions, six options, one interaction. No back-and-forth needed. Preference gathering that requires nuanced ranking becomes a drag-and-drop exercise with `rank_priorities`. The tool respects graceful degradation β€” if the user ignores the widget and types freely, Claude handles it normally. + +#### Widget UI Details (from cross-platform testing) + +Several undocumented UI features were discovered through testing: + +- **"Something else" option:** Automatically added to ALL widget types as a free-text alternative β€” not in the schema, not controllable by the model +- **"Skip" button:** Present on all widget types, allowing users to bypass the question +- **Keyboard shortcuts:** Displayed at the bottom of the widget β€” ↑↓ to navigate, Enter to select, ⌘Enter to submit, Esc to skip +- **Selection counter:** On `multi_select`, shows "0 selected" and updates as the user clicks options +- **Drag handles:** On `rank_priorities`, shows β Ώ dot handles with "Drag to re-order" instruction +- **Localization:** Widget labels adapt to the device language β€” e.g., `rank_priorities` output shows "Classificato:" on Italian devices +- **Pagination:** When multiple questions are used, shows "N of 3" with < > navigation arrows +- **Memory integration:** Claude personalizes option text using stored memory about the user + +> **πŸ“Έ IMAGE: `fig_06_ask_user_input_widget.png`** +> Screenshot showing all three widget types: single_select buttons, multi_select chips with selection counter, and rank_priorities with drag handles. +> *[Upcoming]* + +### `message_compose_v1`: Strategic Message Drafting + +This tool drafts messages (emails, texts, Slack messages) and presents them in a card UI with native app integration buttons. + +The most powerful feature is **strategic variants**. For high-stakes communications, Claude generates 2–3 fundamentally different approaches β€” not just tonal variations, but different strategies that lead to different outcomes. "Polite decline" vs. "Suggest alternative" vs. "Delegate" each prioritize something different. The user sees labeled tabs and chooses the approach that fits their situation. + +Three message types are supported: `email` (with subject line and mail integration), `textMessage` ("Open in Messages" button), and `other` ("Copy" button for Slack, LinkedIn, etc.). + +#### UI Corrections (v1.3) + +Cross-platform testing revealed several differences from the v1.2 description: + +- **Primary button:** The main button is **"Send via Gmail"** (with a Gmail icon), not "Open in Mail" as previously documented +- **Dropdown:** A chevron reveals a dropdown with two options: "Send via Gmail" and "Open in Mail" β€” the user can choose their mail client +- **No recipient field:** The schema has no `to` parameter β€” recipients must be added manually after the message opens in the mail client +- **Subject + body transfer:** Both fields transfer correctly to Gmail and Outlook +- **Auto-signing:** Claude signs the message with the user's name from memory +- **Copy icon:** Present on all message cards for quick clipboard access + +> **πŸ“Έ IMAGE: `fig_07_message_compose_card.png`** +> Screenshot showing the message card UI with the "Send via Gmail" primary button, dropdown chevron revealing mail client options, subject line, body text, and variant tabs. +> *[Upcoming]* + +--- + +## Chapter 5 β€” Visualization: Inline Charts + +`chart_display_v0` is designed to render interactive charts directly inline in the chat β€” no artifacts, no code execution, no external libraries. In theory, it is the fastest path from data to visualization in the entire Claude ecosystem. In practice, it is the clearest example of a tool that shipped before it was ready. + +**Platform:** Mobile App only (deferred via `tool_search`). On browser and desktop, Claude falls back to creating a React artifact with Recharts β€” the chart opens in the artifact sidebar rather than appearing inline in the conversation. + +> **⚠️ Mobile crash bug (confirmed):** As of February 15, 2026, `chart_display_v0` crashes the Claude mobile app on every chart type tested (line, bar, scatter). The tool is discovered and called successfully, but the app terminates the moment it attempts to render. Reproduced across fresh chats and Project chats. This is not a transient glitch β€” it is a consistently reproducible crash that suggests the mobile chart renderer was never fully implemented. The tool exists in the deferred toolkit, Claude will find it and call it, but the result is a force-close. This makes `chart_display_v0` the only tool in the entire toolkit that is technically available but functionally broken β€” a useful reminder that `v0` means what it says. + +For readers: **do not rely on this tool**. If you need charts in Claude, use a React artifact (works on all platforms) or code execution with matplotlib (browser and desktop). The inline chart tool is documented here for completeness and because it reveals how Anthropic's tool pipeline works β€” tools can be discoverable and callable before they are stable. + +The chart appears directly in the conversation stream, below Claude's text. No artifact sidebar opens. The chart is interactive β€” hover over any data point to see its exact value, click a legend entry to hide or show a series, and the chart resizes responsively to the chat width. + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `series` | array | Yes | One or more data series to plot | +| `style` | string | Yes | `'line'`, `'bar'`, `'scatter'` | +| `title` | string | No | Chart title | +| `x_axis` | object | No | X-axis configuration | +| `y_axis` | object | No | Y-axis configuration | + +The tool supports at minimum line charts, bar charts, and scatter plots. Charts appear to be interactive: hover tooltips showing exact values, legend toggling, and responsive sizing within the chat interface. + +> **πŸ“Έ IMAGE: `fig_08_inline_chart.png`** +> Screenshot of an inline interactive chart rendered by `chart_display_v0`. +> *[Upcoming]* + +#### When to Use `chart_display_v0` vs. Alternatives + +| Method | Setup | Inline? | Interactive? | Customizable? | Platform | +| --- | --- | --- | --- | --- | --- | +| `chart_display_v0` | None | Yes | Yes | Limited | Mobile only | +| React artifact (Recharts) | Code gen | No (artifact) | Yes | High | All | +| Code execution (matplotlib) | Python | No (image) | No | High | Browser + Desktop | +| HTML artifact (Chart.js) | Code gen | No (artifact) | Yes | High | All | + +Use `chart_display_v0` for quick visualization during conversation on mobile. Use artifacts for polished, highly customized visualizations. Use code execution when you need programmatic control or data processing. Key limitation: no SVG/PNG export β€” if the user needs to save the chart, use a code artifact instead. + +--- + +## Chapter 6 β€” Calendar & Device Integration + +Eight tools handle scheduling and device-level functionality. Six manage calendar events (search, create, update, delete), and two create alarms and timers. Together, they make Claude a capable personal assistant that can interact with your actual schedule and device. + +### The Calendar Suite + +| Tool | Version | Purpose | +| --- | --- | --- | +| `calendar_search_v0` | v0 | List available calendars | +| `event_search_v0` | v0 | Search events in a time range | +| `event_create_v0` | v0 | Create a single event | +| `event_create_v1` | v1 | Create multiple events (batch) | +| `event_update_v0` | v0 | Update existing events | +| `event_delete_v0` | v0 | Delete events | + +**Platform:** All 6 calendar tools are mobile-only deferred tools, discovered via `tool_search`. On browser and desktop, Claude responds with: "I can only search Google Drive documents, not Google Calendar." + +> **⚠️ Project vs. standard chat β€” different tools, different data.** If you use calendar features inside a Claude Project with Google Calendar connected, you get a **completely different set of tools** (MCP Connector tools like `list_gcal_calendars`) with different IDs, different response formats, and different account visibility. IDs from one environment don't work in the other. The deferred tools documented in this chapter only appear in standard mobile chats. See "The Dual-Layer Architecture" below for the full comparison. + +**Connection required:** Calendar tools require connecting Google Calendar in Claude.ai Settings β†’ Connectors. This is **not connected by default** β€” users must explicitly enable it. Without the connection, the tools will not function even on mobile. + +Most calendar operations follow a two-step pattern: search to find relevant events and get their IDs, then act (update or delete) using those IDs. Claude typically calls `user_time_v0` first to establish the timezone context, then constructs ISO 8601 timestamps for the calendar API. + +The `v0` β†’ `v1` evolution on `event_create` reveals a paradigm shift: `v0` creates a **draft/template** that requires user confirmation in the mobile UI before the event is committed β€” it returns only a string message and the event does not appear in search results until confirmed. Once the user confirms, the event is created with status **"confirmed"** and the `description` field persists correctly. `v1` creates events **directly on the server** without user confirmation and returns structured `{calendar_id, event_id}` pairs with batch support. In testing, v1-created events showed **"confirmed"** status in some sessions and **"tentative"** in others β€” the status may depend on the calendar provider or account configuration. The `description` field did not persist in v1 testing (see Description field bug below). For programmatic workflows needing IDs, v1 is the only option; for user-facing event creation with full data fidelity, v0 is more reliable. + +#### The Dual-Layer Architecture + +Testing revealed a significant architectural detail: Claude's calendar system operates on **two parallel layers** that are completely incompatible. Using calendar features in a Project gives you entirely different tools, different IDs, and different account visibility than using them in a standard mobile chat. An event ID from one layer cannot be used in the other. This is the single most important thing to understand about Claude's calendar system. + +**Layer 1 β€” Google Calendar API** (MCP/Connector tools: `list_gcal_calendars`, `list_gcal_events`, `fetch_gcal_event`, `find_free_time`): Always-loaded when Google Calendar is connected as a Connector in a Project. These are **thin wrappers around the raw Google Calendar API** β€” responses are `calendar#calendarListEntry` objects with `etag`, `colorId`, `notificationSettings`, `conferenceProperties`, and other native Google fields. Uses email-style calendar IDs. Returns rich data but only sees the **primary** connected Google account (3 calendars in testing vs 15 for Layer 2). + +**Layer 2 β€” Event management tools** (`calendar_search_v0`, `event_create_v0/v1`, `event_search_v0`, `event_update_v0`, `event_delete_v0`): Mobile-only deferred tools discovered via `tool_search`. These operate through Anthropic's **intermediate abstraction layer** β€” responses are simplified with clean `{status, calendars/events}` envelopes, numeric string IDs, and a `name` field (not Google's `summary`). Can see **all** connected accounts (15 calendars across 4 accounts in testing). + +The two layers do not share IDs and cannot cross-reference. Layer 1 uses email-style calendar IDs and long alphanumeric event IDs. Layer 2 uses **internal numeric string IDs** (e.g., `calendar_id: "12"`, `event_id: "1256"`) across all tools. The architectural separation likely reflects their development history: the deferred tools were built as a consumer-friendly mobile feature with multi-account abstraction, while the MCP Connector tools were added later as a direct API passthrough for power users in Projects. + +#### Calendar Gotchas + +**Default calendar selection:** When creating events without specifying `calendar_id`, the tool may default to a secondary account rather than the primary calendar. Users with multiple Google accounts should specify the calendar explicitly. + +**Description field bug (v1 only):** In testing, the `description` parameter passed to `event_create_v1` was not persisted β€” `event_search_v0` returned it as empty. However, `event_create_v0` (after user confirmation) persists descriptions correctly. This appears to be a v1-specific bug or limitation. + +**Event creation response:** `event_create_v1` returns a `create_results` array containing `{calendar_id, event_id}` β€” both numeric internal IDs needed for subsequent update/delete operations. `event_create_v0` returns only a string confirmation message without IDs β€” use `event_search_v0` to retrieve IDs after v0 creation. + +**All-day events:** `event_create_v0` accepts `all_day: true` without requiring `end_time`. However, `event_create_v1` requires `end_time` even for all-day events β€” omitting it returns: "DTEND and DURATION cannot both be null." Set `end_time` to the next day's midnight (e.g., start `2026-02-17T00:00:00`, end `2026-02-18T00:00:00`). + +**Nudges (reminders):** Events in the search response include a `nudges` array containing reminder settings (e.g., `{"method": "email", "minutes_before": 60}` or `{"method": "notification", "minutes_before": 30}`). Nudges cannot be set via `event_create` β€” the parameter is not in the creation schema. However, they **can** be set and modified via `event_update_v0`, which replaces the default reminder with the specified configuration. + +**⚠️ Recurring event dangers (confirmed data loss):** The behavior of `event_update_v0` on recurring events depends critically on whether `start_time` is included: + +- **Update WITHOUT `start_time`** (e.g., changing only `location` or `title`): Applies to **all instances** in the series. The recurrence chain survives intact. This is safe. +- **Update WITH `start_time`** (targeting a specific occurrence): **Severs the recurrence chain** β€” the targeted instance receives the update, but all other instances permanently disappear. In testing, updating one Friday occurrence of a weekly meeting caused all future weeks to vanish, requiring re-invitation from the organizer. This happens on both owned and non-owned events. +- **Delete:** Removes **all instances** (past and future) of the recurring series. There is no "delete this instance only" option. + +**Never include `start_time` in an update to a recurring event unless you intend to destroy the series.** There is no "this instance only" modifier. + +**Attendees and nudges via update:** While `event_create_v0` silently ignores the `attendees` parameter, `event_update_v0` can successfully **add attendees and modify nudges** on existing events. Both persist across all instances when updated without `start_time`. This means the workaround for adding guests is: create the event first, then update it with attendees. + +**Attendees silently ignored on create:** The `attendees` parameter can be passed to `event_create_v0` without error, but it is **silently dropped** β€” no guests are added to the created event. To add attendees, create the event first via v0 (confirm) or v1, then use `event_update_v0` with the attendees array. + +**Recurrence:** Recurring events can be created via `event_create_v0` using the three-field format: `{"frequency": "weekly", "human_readable_frequency": "weekly", "rrule": "FREQ=WEEKLY;WKST=MO;BYDAY=MO"}`. The format mirrors what `event_search_v0` returns for existing recurring events. Simple formats and bare RRULE strings are rejected β€” only the three-field format works. Since v0 requires user confirmation, the user must approve the event in the UI before it commits. `event_create_v1` does not support recurrence at all. + +> **πŸ“Έ IMAGE: `fig_09_calendar_event.png`** +> Screenshot showing Claude creating a calendar event. +> *[Upcoming]* + +### Alarms & Timers + +`alarm_create_v0` and `timer_create_v0` are **mobile-only deferred tools** β€” they are discovered via `tool_search` and create actual device-level alarms and timers through OS integration. + +**Platform:** Mobile App only. On browser and desktop, these tools are completely absent (not merely limited) β€” Claude falls back to suggesting Google timer, a voice assistant, or creating an artifact-based timer. + +#### `alarm_create_v0` + +Creates alarms at a specific clock time with optional recurrence (weekday array) and vibration control. On mobile, this creates an actual device alarm that fires even if the Claude app is closed. + +The alarm widget displays: bell icon, time, label, and a "View alarms" link (localized β€” e.g., "Vedi sveglie" on Italian devices). A confirmation message reads "This alarm was set on your device" (localized β€” "Questa sveglia Γ¨ stata impostata sul tuo dispositivo"). + +> **πŸ“Έ IMAGE: `fig_10_alarm_widget.png`** +> Screenshot of the alarm widget on mobile (Italian locale), showing bell icon, time, label, and "Vedi sveglie" link. +> *[Upcoming]* + +#### `timer_create_v0` + +Creates countdown timers from a duration in seconds. Claude converts natural language ("5 minutes" β†’ 300 seconds) automatically. On mobile, this creates an actual device timer. + +The timer widget displays: clock icon, duration, and a "View timers" link (localized β€” "Vedi Timer"). + +> **πŸ“Έ IMAGE: `fig_11_timer_widget.png`** +> Screenshot of the timer widget on mobile, showing clock icon and duration. +> *[Upcoming]* + +#### Alarm vs. Timer: When to Use Which + +| | `alarm_create_v0` | `timer_create_v0` | +| --- | --- | --- | +| Input | Clock time (hour + minute) | Duration (seconds) | +| Recurring | Yes (weekday array) | No | +| Parameters | 5 | 2 | +| Best for | "Wake me at 7 AM" | "Timer for 12 minutes" | +| Platform | Mobile only (deferred) | Mobile only (deferred) | +| Desktop/Browser fallback | Suggests voice assistant or Google | Suggests Google timer or artifact | + +--- + +## Chapter 7 β€” Search & Data Tools + +The largest category: eleven tools that retrieve information from the web, Google Places, Google Drive, sports data providers, weather services, and recipe databases. These are the tools that make Claude more than a language model β€” they give it access to live, current information. + +### Web Tools + +`web_search` queries a search engine and returns the top 10 results with snippets. Short queries (1–6 words) perform best. Claude uses it proactively for anything that might have changed since its training data β€” current events, positions held, prices, scores. It is the single most frequently called tool in the entire system. + +The typical research workflow chains `web_search` into `web_fetch`: search to find sources, fetch to read them in full. For example, when a user asks "What did the Fed decide last week?", Claude calls `web_search` with a short query like `"Fed interest rate decision"`, gets 10 snippets with titles, URLs, and preview text, identifies the most authoritative source (a Reuters or AP article), then calls `web_fetch` on that URL to read the full article. The response is synthesized with citations. Claude decides when to search vs. answer from memory based on topic recency β€” fast-changing information (prices, scores, current office holders) triggers a search; stable facts (historical dates, scientific principles) don't. + +`web_fetch` retrieves the full content of a webpage by URL. Important constraint discovered through testing: `web_fetch` can only access URLs that appeared in `web_search` results or were provided directly by the user. Attempting to fetch an arbitrary URL that wasn't surfaced by search or provided by the user is restricted. It cannot access login-gated or paywalled content β€” paywalled pages return only the page shell (navigation menus, headers) with no article body, a silent truncation rather than an explicit error. Common failure modes include JavaScript-heavy sites (which return minimal content) and rate limiting on repeated fetches. + +`image_search` finds images on the web and returns them inline. The tool description mentions dimensions are included, but in testing Claude did not surface pixel dimensions in its response β€” they may be available in the raw tool response metadata but not exposed to the user. It has an unusual constraint: minimum 3 results per call (requesting fewer is bumped to 3), with a maximum of 5 as an upper bound (requesting 5 may return 4). Content safety restrictions apply β€” copyrighted characters, celebrity photos, and graphic content are filtered. + +### Weather + +`weather_fetch` displays an interactive weather widget with a 5-day forecast. It is one of the more polished UI widgets in the toolkit β€” a gradient card that changes appearance based on conditions. + +**Platform:** Browser and Desktop App only. Not available on mobile β€” Claude falls back to `web_search` for weather data, returning text-only results without a widget. + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `latitude` | number | Yes | Location latitude | +| `longitude` | number | Yes | Location longitude | +| `location_name` | string | Yes | Human-readable name (e.g., "Milan, Lombardy, IT") | + +**Widget Features:** +- Blue/dark gradient card that changes by conditions β€” blue for sunny, dark for cloudy/night, rain animation for rain +- Current temperature and conditions prominently displayed +- 5-day forecast with daily highs and precipitation percentage +- "Weather data from Google" attribution at the bottom +- Claude adds a conversational summary below the widget + +**Unit behavior:** The underlying Google Weather API (`weather.googleapis.com`) returns data exclusively in Fahrenheit (`unitsSystem=IMPERIAL`) β€” there is no Celsius toggle at the API level. The widget displays this raw Fahrenheit data. Claude's text summary below the widget converts to the convention of the queried city β€” Celsius for London, Fahrenheit for New York. The system prompt says "use user's home location for units" but actual behavior follows the queried city's convention. The unit conversion is entirely Claude's responsibility, not a widget or API feature. + +**Geographic coverage:** The API does not support all global locations. In testing, Tokyo coordinates returned a 404 error. When the API fails, Claude falls back to `web_search` for weather data. + +**Location label:** The API echoes back whatever `location_name` Claude passes in as input, plus a separate `country` field. The label duplication observed in earlier testing ("MILAN, LOMBARDY, IT, IT" on desktop, "MILAN, ITALY, ITALY" on browser) is likely a front-end rendering artifact from concatenating `location` and `country` fields, not an API difference. The raw API response returns `"location": "Milan, Lombardy, IT"` with `"country": "IT"` as a separate field. + +> **πŸ“Έ IMAGE: `fig_12_weather_widget.png`** +> Screenshots comparing the weather widget on browser vs. desktop app for the same city. Note that the location label is echoed from Claude's input parameter, and the widget always displays Fahrenheit regardless of locale. +> *[Upcoming]* + +### Recipes + +`recipe_display_v0` displays an interactive recipe widget with adjustable servings, built-in timers, and a full-screen cooking mode. It is the most feature-rich widget in the entire toolkit. + +**Platform:** Browser and Desktop App only. Not available on mobile β€” Claude falls back to a plain text recipe in conversation, without interactive features. + +**Widget Features:** +- **Image carousel** at the top β€” web-sourced photos with attribution ("Results from the web") +- Title and description +- **Servings adjuster** with +/- controls β€” all ingredient amounts scale proportionally +- Toolbar with edit/customize, print, and copy icons +- **INGREDIENTS section** with scaled amounts based on selected servings +- **STEPS section** with numbered instructions and inline timers (β–Ά MM:SS format) +- **NOTES section** at bottom on a beige background +- **"Get cooking" / "Start cooking" button** β€” launches a full-screen step-by-step wizard: + - One step at a time with < > navigation ("Step N of N") + - Contextual timers only on steps that have `timer_seconds` set + - Timer states: blue "Start" β†’ counting down β†’ green "Done!" + - Ingredient amounts shown inline in step text, scaled to current servings +- Timers work in both views: inline play button (β–Ά) and cooking mode (Start/Done) + +**Watch Out:** +- Minor rounding in ingredient scaling (e.g., 1.3Γ— may show 2.5 instead of 2.6 for some values) +- Grammar quirk: "1 teaspoons" β€” the widget doesn't singularize units for quantity 1 +- Default servings and images may vary between sessions β€” Claude chooses the serving count (schema default is 4), and the recipe widget sources different images per session. This is not a platform-specific difference but a per-generation variation +- Mobile fallback: plain text recipe in conversation (no widget, no cooking mode) + +> **πŸ“Έ IMAGE: `fig_13_recipe_widget.png`** +> Screenshots comparing the recipe widget on browser vs. desktop app for the same recipe, showing per-generation variations in servings and images. +> *[Upcoming]* + +> **πŸ“Έ IMAGE: `fig_14_recipe_cooking_mode.png`** +> Screenshots of the cooking mode: step-by-step wizard with navigation arrows, a timer in "Start" state, and a timer in "Done!" state. +> *[Upcoming]* + +### Places & Maps + +`places_search` supports up to 10 simultaneous queries against Google Places, with results deduplicated across queries. Each query can specify its own `max_results` (1–10), and an optional `location_bias_lat`/`location_bias_lng` biases results geographically. The data returned is rich: name, address, coordinates, rating, review count, hours, price level, place types, and full review text. + +`places_map_display_v0` renders interactive maps inline β€” in either simple marker mode or full itinerary mode with multi-day routing, travel times, and tour guide notes. + +#### Markers Mode (from cross-platform testing) + +- Rating badges displayed on map markers +- **Sidebar:** Title, Copy dropdown (text/table export), photo + rating + reviews + category per location +- **Click marker β†’** expanded card: large photo, "Directions" button (arrow icon), phone number, website link, "Notes from Claude" section, close (Γ—) button +- "Directions" triggers an **"Open external link" confirmation dialog** ("You're leaving Claude to visit an external link:") showing the full Google Maps URL, with "Cancel" and "Open link" buttons +- "1 of 3" pagination for browsing through locations + +#### Itinerary Mode (from cross-platform testing) + +- Blue route lines connecting numbered stops with photo thumbnails on the map +- Title + narrative description +- **"Open route" button β†’** Google Maps multi-stop URL (note: opens directly with **no confirmation dialog** β€” inconsistent with markers mode's behavior) +- Copy dropdown (text/table) +- Day sections with arrival times per stop + +The typical workflow chains three tools: ask "best coffee near the Duomo" β†’ Claude calls `user_location_v0` for coordinates β†’ pipes those into `places_search` with location bias β†’ takes the resulting `place_id` values and feeds them into `places_map_display_v0` β†’ an interactive map with pins appears inline. + +> **πŸ“Έ IMAGE: `fig_15_places_markers.png`** +> Screenshot of places markers mode showing the sidebar overview with ratings and the expanded detail popup for a clicked marker. +> *[Upcoming]* + +> **πŸ“Έ IMAGE: `fig_16_places_itinerary.png`** +> Screenshot of places itinerary mode with walking route lines, numbered stops, and "Open route" button. +> *[Upcoming]* + +### Sports Data + +`fetch_sports_data` covers 20 leagues across 10 sports, pulling from SportRadar. It supports three data types: live/recent scores, season standings, and detailed game statistics. The depth of the stats response is remarkable: game stats include per-quarter scoring breakdowns, **60+ statistical fields per player and per team** β€” standard box score stats (FG, 3PT, FT, rebounds, assists, steals, blocks, turnovers, fouls), advanced metrics (`effective_fg_pct`, `true_shooting_pct`, `offensive_rating`, `defensive_rating`, `efficiency_game_score`, `possessions`, `points_per_possession`), zone shooting (`field_goals_at_rim_made/att/pct`, `field_goals_at_midrange`), situation stats (`fast_break_att/made/pct`, `second_chance_att/made/pct`, `points_in_paint_att/made/pct`, `points_off_turnovers`), individual metrics (`pls_min` +/-, `rebounds_pct`, `steals_pct`, `turnovers_pct`), and flags (`double_double`, `triple_double`). Game-level data includes `most_unanswered` run tracking, `bench_points`, and `biggest_lead`. The typical workflow is: fetch scores to get game IDs, then fetch `game_stats` for the specific game of interest. + +> **πŸ“Έ IMAGE: `fig_17_sports_data.png`** +> Screenshot of Claude displaying sports standings or scores. +> *[Upcoming]* + +### Google Drive + +`google_drive_search` uses Google Drive's native query syntax with optional semantic filtering. It supports searching by name, full text, MIME type, date, starred status, folder, and owner. Key gotcha: `fullText` queries require `order_by: "relevance desc"` or results may be empty. The `owners`, `writers`, and `readers` fields require email addresses β€” not names. **MIME type support is limited to Google Docs and Folders** β€” searching for `application/vnd.google-apps.spreadsheet` returns empty results. Example query: `api_query: "name contains 'Q3' and mimeType = 'application/vnd.google-apps.document'"` returns all Google Docs with "Q3" in the title. + +**Response format (confirmed):** Each result includes: `source` (document title), `document_content` (with indexed spans for citation), and metadata fields: `created_time`, `last_modified_by`, `last_modified_time`, `mime_type`, `owner`, `time_since_created`, `time_since_last_modified`, `url`. Small documents return 100% of content inline. Larger documents are **trimmed** (showing `percentage_of_full_document`) with a reminder to use `google_drive_fetch` for the full text. Very large documents return: "This file is too large." + +`google_drive_fetch` retrieves full Google Doc contents by document ID. It supports batch fetching via an array of IDs. Important limitation: Google Docs only β€” not Sheets, not Slides. Error handling is inconsistent: Folders and Sheets return a clean message ("The contents of this file cannot be retrieved. Only Google Docs are supported, and this document has a MIME type of [type]"), while Slides return a raw `error -32000` with no human-readable explanation. + +--- + +## Chapter 8 β€” The Memory Stack: How Claude Remembers You + +Three tools form Claude's memory system, operating at different levels of persistence and scope. Understanding this stack explains why Claude sometimes "remembers" things and sometimes doesn't. + +### The Three-Layer Model + +| Layer | Tool | What It Stores | Persistence | Scope | +| --- | --- | --- | --- | --- | +| Identity | `memory_user_edits` | Facts about the user | Permanent (until removed) | Global per project | +| Episodic (topic) | `conversation_search` | Past conversation content | Until chat deleted | Project-scoped | +| Episodic (time) | `recent_chats` | Recent conversations | Until chat deleted | Project-scoped | + +`memory_user_edits` is the most thoroughly documented tool in this ecosystem, thanks to the author's prior guide ([github.com/frmoretto/claude-memory-user-edits-guide](https://github.com/frmoretto/claude-memory-user-edits-guide)). The core insight: memory edits work for **facts**, not **behaviors**. "User works at Acme Corp" persists reliably; "Always check docs first" does not. The tool supports four commands: `view`, `add`, `remove`, `replace`. Maximum 30 edits, 200 characters each (hard server limit β€” the parameter schema advertises 500 but the server rejects anything over 200). + +> **πŸ“Έ IMAGE: `fig_18_memory_view.png`** +> Screenshot of Claude showing stored memory edits. +> *[Upcoming]* + +`conversation_search` and `recent_chats` provide episodic recall β€” the ability to reference what was discussed in past conversations. The first searches by keyword, the second retrieves by time. Both respect project boundaries: conversations in different Claude Projects are isolated from each other. + +When layers conflict β€” for example, `memory_user_edits` says "User works at Acme" but a recent conversation says "I just left Acme" β€” Claude prioritizes the most recent information from the conversation. However, the stale memory edit persists and may resurface in future conversations until explicitly updated or removed. This is the most common source of "Claude remembers wrong things" complaints. The fix is simple: tell Claude to update or remove the outdated memory. + +### Memory Settings + +Memory behavior is controlled by toggles in Settings β†’ Capabilities: + +- **Memory toggle:** Master on/off for the memory system +- **"Generate memory from chat history" toggle:** Controls whether Claude automatically derives memory edits from conversations +- **"Search and reference chats" toggle:** Controls whether `conversation_search` and `recent_chats` are available +- **"Memory from your chats" preview card:** Shows when memory was last updated (e.g., "Updated 3 hours ago") +- **Project scoping:** Memory in one Project is isolated from memory in other Projects and from standard chats + +#### `conversation_search` vs. `recent_chats`: When to Use Which + +| | `conversation_search` | `recent_chats` | +| --- | --- | --- | +| Query type | Topic / keyword | Time-based | +| Best for | "Did we discuss X?" | "What was my last chat?" | +| Params | `query` + `max_results` | `n` + `sort_order` + `before`/`after` | +| Search tip | Use nouns not verbs β€” "Python migration" works, "discussed about" doesn't | Use `before`/`after` datetime filters for specific ranges | + +--- + +## Chapter 9 β€” Computer Use: Files, Code & Artifacts + +Five tools give Claude access to a Linux computer (Ubuntu 24) for file creation, code execution, and artifact production. These power the "Create Files" feature in Claude.ai. + +| Tool | Purpose | +| --- | --- | +| `bash_tool` | Execute shell commands | +| `view` | Read files, directories, and images | +| `create_file` | Create new files with content | +| `str_replace` | Edit existing files (find and replace) | +| `present_files` | Share files with the user for download | + +The computer use tools are architecturally distinct from other tools: they operate on a sandboxed Linux environment with network access (limited to whitelisted domains), a filesystem that resets between tasks, and a skill system that provides best-practice templates for document creation. Files are created in `/home/claude`, finalized to `/mnt/user-data/outputs`, and shared via `present_files`. + +`str_replace` has an unusual design constraint: the search string must appear exactly once in the file. If it matches zero times, the edit fails with the exact error: "String to replace not found in file". If it matches multiple times, the edit fails with: "String to replace found multiple times, must be unique". Both error messages confirmed in testing. This forces precise, targeted edits rather than bulk find-and-replace operations. + +The sandboxed environment resets between tasks β€” there is no persistent filesystem across conversations. Network access is limited to a whitelist of domains (npm, PyPI, GitHub, Ubuntu repos, and the Anthropic API), so Claude cannot fetch arbitrary URLs from within code execution. Attempting to reach an unlisted domain returns an HTTP 403 Forbidden from the egress proxy with the header `x-deny-reason: host_not_allowed`. The proxy is Envoy-based and uses JWT authentication for container identification. + +When the output is a React component, HTML page, SVG, or Mermaid diagram, Claude creates an artifact (rendered inline in the chat or in a sidebar). When the output is a document (docx, xlsx, pptx, pdf), Claude creates a file and shares it via `present_files` as a downloadable card. + +> **πŸ“Έ IMAGE: `fig_19_file_creation.png`** +> Screenshot of Claude creating and presenting a file. +> *[Upcoming]* + +### Execution Settings + +Computer use behavior is controlled by toggles in Settings β†’ Capabilities: + +- **"Cloud code execution and file creation" toggle:** Master on/off for computer use tools +- **"Allow network egress" toggle:** Controls whether the sandbox can access external domains +- **"Domain allowlist" dropdown:** "Package managers only" (default) or custom domain list +- **"AI-powered artifacts" toggle:** Separate from basic artifacts β€” controls whether Claude can use the Anthropic API within artifacts (Claude-in-Claude) + +#### The Skill System + +Claude.ai ships with public skills for document types: `docx`, `pptx`, `xlsx`, `pdf`, `frontend-design`, and `product-self-knowledge`. Each skill is a markdown file (e.g., `/mnt/skills/public/docx/SKILL.md`) containing best practices, code templates, and validation procedures. Users can add custom skills as markdown files in their Projects, placed in `/mnt/skills/user/`. + +Skills function as just-in-time instruction: before creating a Word document, Claude reads the docx skill file to learn formatting rules, validation steps, and common pitfalls β€” producing dramatically better output than without the skill. This pattern explains why document creation quality varies significantly between standard chats and properly configured Projects. + +--- + +## Chapter 10 β€” The Meta-Tool: tool_search + +The most architecturally significant tool in the entire system is `tool_search` β€” a tool whose only purpose is discovering other tools. It represents a recursive layer in Claude.ai's architecture: the AI can search for its own capabilities at runtime. + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `query` | string | Yes | Search keywords to match against tool names and descriptions | +| `limit` | integer | No | Maximum results (1-20, default 5) | + +### Platform-Dependent Behavior (v1.3 critical finding) + +`tool_search` is not a universal capability β€” it behaves fundamentally differently depending on your platform: + +- **Browser (claude.ai):** `tool_search` does not exist. There is no deferred loading system. All available tools are always-loaded. +- **Desktop App:** `tool_search` exists but only discovers MCP integration tools. If you have Claude in Chrome and Filesystem connected, it returns all 32 MCP tools (18 Chrome + 14 Filesystem) **regardless of query** β€” keywords only affect result ordering, not which tools appear. It behaves as a "load everything" operation rather than a filtered search. It does **not** discover consumer deferred tools like `alarm_create_v0` or `chart_display_v0`. +- **Mobile App:** `tool_search` exists and discovers the 11 consumer deferred tools documented in this book. This is the only platform where the discovery methodology below is reproducible. + +This is the single most important caveat in this chapter: **the discovery log below was produced on the mobile app and is only reproducible there.** + +### The Enumeration Methodology + +This book was made possible by systematic keyword sweeps through `tool_search` on the Claude mobile app. The methodology: start with broad functional categories ("user," "create," "search," "display"), then narrow with specific terms ("alarm," "chart," "calendar," "timer"). Each query returns matching tools with their full parameter schemas. + +### The Discovery Log + +The following are the actual `tool_search` calls used to enumerate the toolkit for this book, conducted on the **Claude mobile app** (no Project, no MCP integrations): + +> **Environment note:** These results are only reproducible on the Claude mobile app in a standard chat without Project or MCP connections. On the browser, `tool_search` does not exist. On the desktop app, it returns MCP tools instead. + +> **Reproducibility note:** `tool_search` uses fuzzy matching β€” the same query may return different results across sessions. In verification testing, `query="user"` returned `user_location_v0` plus 6 other tools but **missed** `user_time_v0`, which required a separate query ("time clock current"). Tools bleed across unrelated queries (e.g., `user_location_v0` appeared in nearly every search). The discovery log below represents the results from the original enumeration session; your results may vary. The key is that all 11 tools are discoverable β€” just not always from the same queries. + +We started with the broadest possible query: "user". This immediately surfaced the two context tools. + +``` +Query: tool_search(query="user", limit=20) +Results: + β†’ user_time_v0 β€” "Retrieves current time in user timezone" + β†’ user_location_v0 β€” "Gets user geographic location" +``` + +Pivoting to action verbs β€” "create display generate" β€” revealed the visualization and scheduling tools. + +``` +Query: tool_search(query="create display generate", limit=20) +Results: + β†’ chart_display_v0 β€” "Renders inline interactive charts" + β†’ alarm_create_v0 β€” "Creates device alarms" + β†’ timer_create_v0 β€” "Creates countdown timers" + β†’ event_create_v0 β€” "Creates calendar events" + β†’ event_create_v1 β€” "Batch calendar event creation" +``` + +Data retrieval queries surfaced the calendar search tools. + +``` +Query: tool_search(query="search fetch data", limit=20) +Results: + β†’ event_search_v0 β€” "Searches calendar events" + β†’ calendar_search_v0 β€” "Lists available calendars" +``` + +The search queries "send message email" returned only tools already found, suggesting the messaging tools (`message_compose_v1`, `ask_user_input_v0`) are always-loaded and therefore not indexed by `tool_search`. + +``` +Query: tool_search(query="send message email slack reminder", limit=20) +Results: + β†’ alarm_create_v0 (again) + β†’ event_create_v0 (again) + β†’ timer_create_v0 (again) + +Query: tool_search(query="map place weather stock price translate", limit=20) +Results: + β†’ user_location_v0 (again) + β†’ event_create_v0 (again) +``` + +The most telling result was the empty return for media processing queries β€” confirmation that media processing, if it exists at all in deferred form, uses naming conventions our sweeps didn't catch. + +``` +Query: tool_search(query="audio image video file convert", limit=20) +Results: NONE + β†’ Confirms no media processing tools exist in the deferred toolkit +``` + +Finally, mutation verbs surfaced the remaining calendar tools. + +``` +Query: tool_search(query="update delete remove", limit=20) +Results: + β†’ event_update_v0 β€” "Updates existing events" + β†’ event_delete_v0 β€” "Deletes calendar events" +``` + +Negative results are as important as positive ones. The empty return for "audio image video file convert" confirms that media processing capabilities, if they exist, are always-loaded (like `image_search`) rather than deferred. + +> **πŸ“Έ IMAGE: `fig_20_tool_search_results.png`** +> Screenshot showing the raw output of a `tool_search` call on mobile. +> *[Upcoming]* + + +### What Might Still Be Hiding + +Keyword-based discovery has inherent limitations β€” you can only find tools matching your search terms. Tools with unexpected names or descriptions might not surface. Additionally, some tools may be gated behind features, account tiers, or A/B tests and therefore invisible to `tool_search` in some sessions. The iOS Reminders tools discovered by Federico Viticci at MacStories (`reminder_list_search_v0`, `reminder_create_v0`, etc.) are not discoverable via `tool_search` from the web interface, confirming that platform-specific tools exist beyond what web-based discovery can reach. + +#### Schema Depth Limitation + +A critical finding from testing: `tool_search` is a **discovery and loading mechanism**, not a full schema introspection tool. It returns only top-level parameter names and types with descriptions truncated at approximately 60 characters. It does **not** expose nested object structures (e.g., the `recurrence` object inside `event_create_v0`), array item schemas (e.g., what fields go inside each `event_updates` element), enum values, defaults, or constraints. The only way to determine these deeper schema details is behavioral testing β€” calling the tools with various payloads and observing what gets accepted, rejected, or returned. + +The platform fragmentation documented in Chapter 2 adds another dimension: tools that exist on one platform may not exist on others, and `tool_search` itself behaves differently across platforms. A complete enumeration would require running discovery sweeps on every platform β€” web, desktop app, mobile app (Android and iOS separately) β€” and comparing the results. + +--- + +## Chapter 11 β€” The Complete Tool Reference + +This chapter provides a quick-reference index to every documented tool. For full parameter schemas, response formats, and usage examples, see the corresponding Tool Card in the Technical Annex. + +### Deferred Tools (loaded on demand via `tool_search` β€” mobile only) + +| Tool | Category | What It Does | Card | +| --- | --- | --- | --- | +| `user_time_v0` | Context | Returns current time in user's timezone | [1](#tool-card-1) | +| `user_location_v0` | Context | Gets user coordinates (requires permission) | [2](#tool-card-2) | +| `chart_display_v0` | Visualization | Renders inline interactive charts | [3](#tool-card-3) | +| `alarm_create_v0` | Device | Creates device alarms (mobile-native) | [6](#tool-card-6) | +| `timer_create_v0` | Device | Creates countdown timers (mobile-native) | [7](#tool-card-7) | +| `calendar_search_v0` | Calendar | Lists available calendars | [8](#tool-card-8) | +| `event_search_v0` | Calendar | Searches events in a time range | [9](#tool-card-9) | +| `event_create_v0` | Calendar | Creates a calendar event draft (requires user confirmation) | [10](#tool-card-10) | +| `event_create_v1` | Calendar | Creates multiple events (batch) | [11](#tool-card-11) | +| `event_update_v0` | Calendar | Updates existing events | [12](#tool-card-12) | +| `event_delete_v0` | Calendar | Deletes calendar events | [13](#tool-card-13) | + +### Always-Loaded Tools + +| Tool | Category | What It Does | Card | +| --- | --- | --- | --- | +| `web_search` | Search | Queries search engine, returns top 10 results | [14](#tool-card-14) | +| `web_fetch` | Search | Fetches full webpage content by URL | [15](#tool-card-15) | +| `image_search` | Search | Finds and returns inline images | [16](#tool-card-16) | +| `places_search` | Search | Multi-query Google Places search | [17](#tool-card-17) | +| `places_map_display_v0` | Search | Renders interactive maps (markers or itinerary) | [18](#tool-card-18) | +| `fetch_sports_data` | Search | Scores, standings, and game stats for 20 leagues | [19](#tool-card-19) | +| `google_drive_search` | Search | Searches Google Drive with native query syntax | [20](#tool-card-20) | +| `google_drive_fetch` | Search | Retrieves Google Doc contents by ID | [21](#tool-card-21) | +| `weather_fetch` | Search | Interactive weather widget with 5-day forecast | [26](#tool-card-26) | +| `recipe_display_v0` | Interaction | Interactive recipe widget with cooking mode | [27](#tool-card-27) | +| `memory_user_edits` | Memory | Manages persistent memory edits (view/add/remove/replace) | [22](#tool-card-22) | +| `conversation_search` | Memory | Keyword search across past conversations | [23](#tool-card-23) | +| `recent_chats` | Memory | Time-based retrieval of recent conversations | [24](#tool-card-24) | +| `ask_user_input_v0` | Interaction | Renders interactive choice widgets | [4](#tool-card-4) | +| `message_compose_v1` | Interaction | Drafts messages with strategic variants | [5](#tool-card-5) | +| `end_conversation` | System | Permanently ends the conversation | [28](#tool-card-28) | +| `bash_tool` | Computer Use | Executes shell commands in sandbox | β€” | +| `view` | Computer Use | Reads files, directories, images | β€” | +| `create_file` | Computer Use | Creates new files with content | β€” | +| `str_replace` | Computer Use | Edits files (unique string replacement) | β€” | +| `present_files` | Computer Use | Shares files with user for download | β€” | +| `tool_search` | Meta | Discovers deferred tools by keyword | [25](#tool-card-25) | + +--- + +## Chapter 12 β€” What Comes Next + +The tool ecosystem documented in this book is a snapshot of February 2026. It will change. Understanding the trajectory helps predict what's coming and where the opportunities lie. + +### The MCP Convergence + +Anthropic's Model Context Protocol (MCP) is an open standard for connecting AI tools to external services. Many of the internal tools documented here β€” calendar, alarms, Google Drive β€” could theoretically be implemented as MCP servers. The strategic question is whether Anthropic will eventually expose these internal tools as MCP servers (enabling third-party access) or maintain the current separation between consumer tools and developer APIs. + +The platform architecture findings in v1.3 add nuance to this question. On the desktop app, `tool_search` already discovers MCP tools (Chrome, Filesystem) rather than consumer deferred tools β€” suggesting that MCP and internal tools already coexist in the same discovery mechanism, just on different platforms. This may be a transitional state or a deliberate architectural separation. + +For developers, the practical implication is clear: understanding these internal tools gives you a blueprint for what to build with MCP. If Claude.ai can render inline charts, set alarms, and display interactive maps, your MCP-powered applications can do the same β€” you just need to build the tools yourself. + +### Building on Top of Hidden Tools + +The most immediate opportunity is using these tools more effectively in Claude.ai itself. Power users who understand `ask_user_input_v0` can structure their conversations for faster, more precise results. Understanding `chart_display_v0` means knowing when to ask for an inline chart vs. an artifact. Knowing about `tool_search` means you can discover capabilities that even Claude doesn't use by default. + +The deeper opportunity is reading the signals. These tools reveal Anthropic's product strategy: investment in mobile-native device integration (alarms, timers), dependency on Google's ecosystem (Places, Drive, Calendar, Weather), incremental versioning rather than breaking changes (v0/v1 coexistence), rich interactive widgets (weather, recipes, maps) that push beyond text-only interfaces, and a clear trajectory toward Claude as a full operating system layer β€” scheduling, file management, communication, and now memory. Every tool in this book is a data point in that trajectory. + +### Open Questions + +Several questions remain unanswered and worth watching: Will MCP eventually replace internal tools, or will they coexist? Will `google_drive_fetch` expand to support Sheets and Slides? Will `chart_display_v0` gain more chart types (pie, histogram) or will artifacts remain the path for complex visualizations? Will the iOS-exclusive Reminders tools expand to Android and web? How will `tool_search` evolve as the toolkit grows β€” will it remain keyword-based or gain semantic matching? Will the platform fragmentation documented in this edition converge toward a unified tool set, or will each platform continue to diverge? The companion repository will track these as they develop. + +--- + +## Appendix A β€” Availability Matrix + +| Tool | Browser | Mobile | Desktop | API | Claude Code | +| --- | --- | --- | --- | --- | --- | +| `user_time_v0` | ❌ | βœ… (deferred) | ❌ | ❌ | ❌ | +| `user_location_v0` | ❌ | βœ… (deferred) | ❌ | ❌ | ❌ | +| `chart_display_v0` | ❌ | βœ… (deferred, ⚠️ crashes) | ❌ | ❌ | ❌ | +| `ask_user_input_v0` | βœ… | βœ… | βœ… | ❌ | ❌ | +| `message_compose_v1` | βœ… | βœ… | βœ… | ❌ | ❌ | +| `alarm_create_v0` | ❌ | βœ… (deferred, native) | ❌ | ❌ | ❌ | +| `timer_create_v0` | ❌ | βœ… (deferred, native) | ❌ | ❌ | ❌ | +| Calendar suite (6) | ❌ | βœ… (deferred, needs connection) | ❌ | ❌ | ❌ | +| `web_search` | βœ… | βœ… | βœ… | βœ…* | ❌ | +| `web_fetch` | βœ… | βœ… | βœ… | βœ…* | ❌ | +| `image_search` | βœ… | βœ… | βœ… | ❌ | ❌ | +| `places_search` | βœ… | βœ… | βœ… | ❌ | ❌ | +| `places_map_display_v0` | βœ… | βœ… | βœ… | ❌ | ❌ | +| `fetch_sports_data` | βœ… | βœ… | βœ… | ❌ | ❌ | +| Google Drive (2) | βœ… | βœ… | βœ… | ❌ | ❌ | +| `weather_fetch` | βœ… | ❌ | βœ… | ❌ | ❌ | +| `recipe_display_v0` | βœ… | ❌ | βœ… | ❌ | ❌ | +| `end_conversation` | βœ… | βœ… | βœ… | ❌ | ❌ | +| Memory tools (3) | βœ… | βœ… | βœ… | ❌ | ❌ | +| Computer Use (5) | βœ… | ❌ | βœ… | ❌ | Different | +| `tool_search` | ❌ | βœ… (consumer) | βœ… (MCP only) | ❌ | ❌ | + +\* `web_search` exists in the API as `web_search_20250305` with different configuration. `web_fetch` is available server-side in the API. All other tools are Claude.ai-exclusive. + +--- + +## Appendix B β€” Discovery Methodology + +This appendix documents the exact methodology used to discover and catalog every tool in this book. The approach is reproducible β€” anyone with a Claude.ai account can verify these findings. + +### Step 1: Broad Keyword Sweeps (Mobile App) + +Using `tool_search` on the **Claude mobile app** with `limit=20`, the following queries were executed systematically: "user", "create display generate", "search fetch data memory notification", "audio image video file convert", "send message email slack reminder", "map place weather stock price translate". Each query's results were recorded, including tool names, parameter schemas, and descriptions. + +**Platform note:** This step is only reproducible on the Claude mobile app. On the browser, `tool_search` does not exist. On the desktop app, it discovers MCP tools instead. + +### Step 2: Schema Extraction + +For each discovered tool, the full parameter schema was captured from `tool_search` results. This includes parameter names, types, required/optional status, and descriptions. For always-loaded tools (not discoverable via `tool_search`), schemas were extracted from Claude's system-level tool definitions. + +### Step 3: Behavioral Testing + +Each tool was called with representative inputs to document response formats, error handling, and edge cases. Testing included: normal usage, boundary conditions (empty inputs, maximum values), and cross-platform comparison across three surfaces (browser, desktop app, mobile app). Automated tests covered 38 scenarios; manual tests covered 34 scenarios across platforms. + +### Step 4: Cross-Platform Verification (v1.3) + +New in this edition: systematic testing across browser, desktop app, and mobile app to document platform-specific behavior. This revealed the platform architecture documented in Chapter 2, including the critical finding that `tool_search` behaves differently on each platform and that many tools are platform-exclusive. + +### Step 5: Cross-Reference with Public Sources + +Every tool name was searched across GitHub, Reddit, LinkedIn, Twitter/X, YouTube, and the broader web to determine documentation status. Anthropic's official docs (docs.anthropic.com, support.claude.com) were checked for each tool. The gap analysis confirmed that the vast majority of tools had zero public documentation by their internal names. + +### Step 6: Peer Validation + +Findings were compared against the small body of existing research: Shlok Khemani's memory tool schemas, Simon Willison's system prompt analysis, Adversa AI's security research, and Federico Viticci's iOS tool discovery. Consistent findings across independent researchers strengthen confidence in the documented schemas. + +--- + +## Appendix C β€” Tool Template for New Discoveries + +Use this template when documenting newly discovered tools. Consistent structure makes the catalog navigable and comparable. + +```markdown +# `tool_name` + +> Category: [category] +> Availability: Claude.ai only / All platforms +> Platform: Browser / Desktop / Mobile / All +> Documentation status: Undocumented / Partial / Official + +## Overview +[One paragraph description] + +## Quick Facts +[Table: name, version, category, params, availability, platform] + +## Parameters +[Table: name, type, required, default, description] + +## Response Format +[JSON example + schema table] + +## When Claude Uses It +[Table: scenario, example user message] + +## Edge Cases & Gotchas +[List of discovered edge cases] + +## Limitations +[List of known limitations] + +## Platform Availability +[Table: platform, available, notes] + +## Changelog +[Date, change] +``` + +--- + +## Appendix D β€” Settings & Connectors Reference + +Claude.ai's settings control which tools are available and how they behave. Understanding these settings is essential for accessing the full toolkit. + +### Settings Sidebar (Browser / Mobile) + +| Section | What It Controls | +| --- | --- | +| General | Language, theme, interface preferences | +| Account | Email, password, account management | +| Privacy | Data handling, conversation history | +| Billing | Plan management, usage limits | +| Usage | Token and message usage statistics | +| Capabilities | Tool toggles (see below) | +| Connectors | External service connections (see below) | +| Claude Code | CLI tool configuration | +| Cowork | Desktop automation configuration | + +### Desktop App Additional Settings + +| Section | What It Controls | +| --- | --- | +| General | Desktop-specific preferences | +| Extensions | MCP server management | +| Developer | Debug and development options | + +### Connectors + +Connectors enable tools that depend on external services. Available connectors: + +| Connector | Required By | Default State | +| --- | --- | --- | +| Google Drive | `google_drive_search`, `google_drive_fetch` | Available, must connect | +| GitHub | Code-related features | Available, must connect | +| Gmail | `message_compose_v1` "Send via Gmail" | Available, must connect | +| Google Calendar | Calendar suite (6 tools) | Available, must connect | +| Claude in Chrome | Desktop MCP browsing tools | Available, must connect | +| Filesystem | Desktop MCP file access tools | Desktop only, must connect | +| Add custom connector | User-defined MCP servers | N/A | + +### Capabilities Toggles + +| Toggle | What It Controls | +| --- | --- | +| Artifacts | Basic artifact rendering (HTML, React, SVG, etc.) | +| AI-powered artifacts | Claude-in-Claude API calls within artifacts | +| Cloud code execution and file creation | Computer use tools (`bash_tool`, `create_file`, etc.) | +| Allow network egress | Sandbox internet access | +| Domain allowlist | Which domains the sandbox can reach | +| Memory (search + generate) | `memory_user_edits`, auto-generation of memories | +| Search and reference chats | `conversation_search`, `recent_chats` | +| Skills | Custom skill files in Projects | + +> **πŸ“Έ IMAGE: `fig_21_settings_connectors.png`** +> Screenshot of the Settings β†’ Connectors page showing available connections. +> *[Upcoming]* + +> **πŸ“Έ IMAGE: `fig_22_settings_capabilities.png`** +> Screenshots of the Settings β†’ Capabilities toggles for Artifacts, Code execution, Memory, and Skills. +> *[Upcoming]* + +--- + +# TECHNICAL ANNEX β€” Detailed Tool Cards + +Each card includes: quick facts, overview, full parameter schema, a JSON call example, trigger scenarios, key gotchas, and platform availability. All response examples have been confirmed through empirical testing across three platforms. + +--- + +### Tool Card 1 + +## `user_time_v0` + +| Property | Detail | +| --- | --- | +| Tool | `user_time_v0` | +| Version | v0 | +| Category | Context | +| Params | 0 | +| Permission | No | +| Platform | Mobile App only (deferred) | +| Docs | None | +| Trigger phrases | "What time is it?" Β· "Current time in Tokyo?" Β· "Is it too late to call?" | + +#### Overview + +Returns current time in ISO 8601 with microsecond precision and UTC offset. See Chapter 3. Mobile only β€” on browser and desktop, Claude states the system date but cannot access local time. + +#### Parameters + +This tool accepts no parameters. + +#### Example Call + +```json +// Call (no parameters) +{} + +// Response +{ + "current_time": "2026-02-14T15:30:45.123456+01:00" +} +``` + +#### When Claude Uses It + +| Scenario | Example | +| --- | --- | +| Time request | "What time is it?" | +| Scheduling | "Is it too late to call London?" | +| Timestamps | "Log this with timestamp" | +| Timezone math | "What time in Tokyo?" | + +#### Watch Out + +- VPN has no effect β€” timezone comes from device, not IP +- Microsecond precision but no caching β€” each call returns a fresh timestamp +- Prerequisite for calendar tools (they need ISO 8601 with correct offset) +- Browser/desktop fallback: Claude states system date but cannot return precise local time + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | States system date only | +| Claude mobile | βœ… | Device timezone, deferred via `tool_search` | +| Claude desktop | ❌ | States system date only | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 2 + +## `user_location_v0` + +| Property | Detail | +| --- | --- | +| Tool | `user_location_v0` | +| Version | v0 | +| Category | Context | +| Params | 1 | +| Permission | Yes β€” two-layer device permission | +| Platform | Mobile App only (deferred) | +| Docs | None | +| Trigger phrases | "Restaurants near me?" Β· "Weather here?" Β· "How far to the airport?" | + +#### Overview + +User geolocation. The only tool requiring explicit permission. Returns coordinates and a reverse-geocoded address. Mobile only β€” on browser and desktop, this tool is absent and Claude asks for location manually. See Chapter 3. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `accuracy` | string | Yes | `"low"` (city-level) or `"high"` (GPS-level) β€” in testing, both returned nearly identical results | + +#### Example Call + +```json +// Call +{"accuracy": "high"} + +// Response (confirmed) +{ + "status": "success", + "latitude": 45.4707004, + "longitude": 9.1248245, + "geocoded": { + "address": "Via Example 15", + "administrative_area": "Lombardia", + "country": "Italia", + "locality": "Milano", + "name": "15", + "postal_code": "20100" + } +} +``` + +#### When Claude Uses It + +| Scenario | Example | +| --- | --- | +| Nearby search | "Restaurants near me?" | +| Weather | "Weather here?" | +| Distance | "How far to the airport?" | + +#### Watch Out + +- **Two permission layers on mobile:** (1) Claude app: "Allow once / Allow always / Cancel" (localized), (2) Android OS: Exact vs. Approximate location +- Result widget: pin icon, full street address, Google Maps thumbnail +- Browser/desktop: tool absent β€” Claude asks user for city/area manually +- **`accuracy` parameter has no observable effect** β€” "high" and "low" returned nearly identical coordinates in testing +- **No `accuracy_meters` field** β€” the response includes `geocoded` address object instead +- **Response includes reverse-geocoded address** with street, city, region, country, postal code + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Absent β€” asks manually | +| Claude mobile | βœ… | GPS, deferred via `tool_search` | +| Claude desktop | ❌ | Absent β€” asks manually | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 3 + +## `chart_display_v0` + +| Property | Detail | +| --- | --- | +| Tool | `chart_display_v0` | +| Version | v0 | +| Category | Visualization | +| Params | 5 | +| Permission | No | +| Platform | Mobile App only (deferred) β€” ⚠️ crashes as of Feb 2026 | +| Docs | None | +| Trigger phrases | "Plot my monthly expenses" Β· "Show a bar chart of..." Β· "Graph these numbers" | + +#### Overview + +Inline interactive charts: line, bar, scatter. Mobile only (deferred) but **currently crashes the app on all chart types** β€” confirmed across fresh chats and Project chats. On browser and desktop, Claude creates a React artifact with Recharts instead. See Chapter 5. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `series` | array | Yes | Data series to plot | +| `style` | string | Yes | `"line"`, `"bar"`, `"scatter"` | +| `title` | string | No | Chart title | +| `x_axis` | object | No | X-axis configuration | +| `y_axis` | object | No | Y-axis configuration | + +#### Example Call + +```json +{ + "series": [ + {"name": "Revenue", "data": [100, 150, 130, 180, 210]}, + {"name": "Costs", "data": [80, 90, 95, 110, 120]} + ], + "style": "line", + "title": "Q1-Q5 Performance", + "x_axis": {"label": "Quarter"}, + "y_axis": {"label": "USD (thousands)"} +} +``` + +#### Watch Out + +- **⚠️ App crashes on rendering** (tested Feb 15, 2026) +- No SVG/PNG export β€” use a code artifact if user needs to save +- Limited chart types (line, bar, scatter) β€” no pie, histogram, heatmap +- Browser/desktop fallback: React artifact with Recharts + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Fallback: React artifact | +| Claude mobile | βœ… (⚠️ crashes) | Deferred, currently broken | +| Claude desktop | ❌ | Fallback: React artifact | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 4 + +## `ask_user_input_v0` + +| Property | Detail | +| --- | --- | +| Tool | `ask_user_input_v0` | +| Version | v0 | +| Category | Interaction | +| Params | 1 (complex) | +| Permission | No | +| Platform | All | +| Docs | None | +| Trigger phrases | "Help me choose between..." Β· "Which do you prefer?" Β· "Rank these options" | + +#### Overview + +Interactive choice widgets: `single_select`, `multi_select`, `rank_priorities`. 1–3 questions, 2–4 options each. See Chapter 4. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `questions` | array | Yes | 1–3 question objects, each with `question`, `type`, and `options` | + +#### Example Call + +```json +{ + "questions": [ + { + "question": "What kind of analysis do you need?", + "type": "single_select", + "options": ["Quick summary", "Deep analysis", "Comparison", "Recommendations"] + }, + { + "question": "Which areas interest you?", + "type": "multi_select", + "options": ["Technical", "Business", "Legal", "Financial"] + } + ] +} +``` + +#### Watch Out + +- Max 3 questions Γ— 4 options β€” Claude must compress if more are needed +- Graceful degradation: if user ignores widget and types freely, Claude handles it +- **"Something else" free-text option** auto-added to ALL widget types (not in schema) +- **"Skip" button** present on all types +- **Keyboard shortcuts:** ↑↓ navigate, Enter select, ⌘Enter submit, Esc skip +- **Selection counter** on multi_select ("0 selected") +- **Drag handles** (β Ώ) on rank_priorities with "Drag to re-order" +- **Pagination** "N of 3" with < > navigation for multiple questions +- Claude personalizes options using stored memory + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Keyboard shortcuts visible | +| Claude mobile | βœ… | Touch-optimized | +| Claude desktop | βœ… | Keyboard shortcuts visible | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 5 + +## `message_compose_v1` + +| Property | Detail | +| --- | --- | +| Tool | `message_compose_v1` | +| Version | v1 | +| Category | Interaction | +| Params | 3 | +| Permission | No | +| Platform | All | +| Docs | Named by Adversa AI | +| Trigger phrases | "Write an email to..." Β· "Draft a text to..." Β· "Help me reply to this message" | + +#### Overview + +Message drafting with native app integration and strategic variants. See Chapter 4. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `kind` | string | Yes | `"email"`, `"textMessage"`, or `"other"` | +| `variants` | array | Yes | Message drafts, each with `label` and `body` (and `subject` for email) | +| `summary_title` | string | Yes | Title shown in share sheet | + +#### Example Call + +```json +{ + "kind": "email", + "summary_title": "Declining the meeting", + "variants": [ + { + "label": "Polite decline", + "subject": "Re: Strategy Meeting Thursday", + "body": "Hi Alex, thanks for the invite. Unfortunately I have a conflict on Thursday. Happy to review any notes afterward." + }, + { + "label": "Suggest alternative", + "subject": "Re: Strategy Meeting Thursday", + "body": "Hi Alex, Thursday doesn't work for me β€” would Friday morning work instead?" + } + ] +} +``` + +#### Watch Out + +- Strategic variants: 2–3 fundamentally different approaches, not just tonal shifts +- **Primary button is "Send via Gmail"** (with Gmail icon), not "Open in Mail" +- **Dropdown chevron** reveals: "Send via Gmail" + "Open in Mail" +- **No recipient field** in schema β€” recipients added manually in mail client +- Subject + body transfer correctly to both Gmail and Outlook +- Claude auto-signs with user's name from memory +- **Copy icon** present on all message cards + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Send via Gmail + Open in Mail | +| Claude mobile | βœ… | Native app integration | +| Claude desktop | βœ… | Send via Gmail + Open in Mail | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 6 + +## `alarm_create_v0` + +| Property | Detail | +| --- | --- | +| Tool | `alarm_create_v0` | +| Version | v0 | +| Category | Scheduling | +| Params | 5 | +| Permission | Likely | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "Wake me at 7 AM" Β· "Set an alarm for 3 PM" Β· "Weekday alarm at 6:30" | + +#### Overview + +Creates alarms at a specific clock time. Supports recurring alarms via weekday array. Mobile-native β€” creates actual device alarms through OS integration. Completely absent on browser and desktop. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `hour` | integer | Yes | 0–23 | +| `minute` | integer | Yes | 0–59 | +| `message` | string | Yes | Alarm label | +| `days` | array | No | Recurring weekdays (e.g., `["monday", "friday"]`) | +| `vibrate` | boolean | No | Enable vibration | + +#### Example Call + +```json +{ + "hour": 7, + "minute": 0, + "message": "Wake up for gym", + "days": ["monday", "wednesday", "friday"], + "vibrate": true +} +``` + +#### Watch Out + +- Creates **actual device-level alarms** β€” fires even if Claude app is closed +- Widget: bell icon, time, label, "View alarms" link (localized β€” "Vedi sveglie" in Italian) +- **Response string:** Returns "Alarm was set on Android device." (or equivalent for iOS) β€” confirms the device platform +- Confirmation: "This alarm was set on your device" (localized) +- Adapts to device language +- **Browser/desktop: tool completely absent** β€” Claude suggests alternatives + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Native device alarm, deferred | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 7 + +## `timer_create_v0` + +| Property | Detail | +| --- | --- | +| Tool | `timer_create_v0` | +| Version | v0 | +| Category | Scheduling | +| Params | 2 | +| Permission | Likely | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "Set a 5-minute timer" Β· "Timer for 12 minutes for pasta" Β· "25-minute focus timer" | + +#### Overview + +Countdown timers from a duration in seconds. Claude converts natural language automatically. Mobile-native β€” creates actual device timers. Completely absent on browser and desktop. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `duration_seconds` | integer | Yes | Duration in seconds | +| `message` | string | Yes | Timer label | + +#### Example Call + +```json +{ + "duration_seconds": 720, + "message": "Pasta is ready" +} +``` + +#### Watch Out + +- Input is always seconds β€” Claude handles conversion from natural language +- No recurring support (unlike alarms) +- Widget: clock icon, duration, "View timers" link (localized β€” "Vedi Timer") +- **Response string:** Returns "Timer was set on Android device." (or equivalent for iOS) +- Creates actual device timer β€” works even if Claude app is closed +- **Browser/desktop: tool completely absent** + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Native device timer, deferred | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 8 + +## `calendar_search_v0` + +| Property | Detail | +| --- | --- | +| Tool | `calendar_search_v0` | +| Version | v0 | +| Category | Calendar | +| Params | 0 | +| Permission | Calendar connection required | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | Called internally β€” triggered when you ask about calendar events | + +#### Overview + +Lists available calendars and their IDs. First call in any calendar workflow. + +#### Parameters + +This tool accepts no parameters. + +#### Example Call + +```json +// Call +{} + +// Response (confirmed) +{ + "status": "success", + "calendars": [ + { + "access_level": "owner", + "account_name": "user@gmail.com", + "color": "#B99AFF", + "id": "12", + "is_primary": true, + "name": "user@gmail.com", + "owner_account": "user@gmail.com" + }, + { + "access_level": "readonly", + "account_name": "user@gmail.com", + "color": "#7BD148", + "id": "10", + "name": "Holidays in Italy", + "owner_account": "it.italian#holiday@group.v.calendar.google.com" + } + ] +} +``` + +**Response fields per calendar:** `id` (numeric string), `name` (display name), `account_name` (parent Google account email), `owner_account` (calendar owner β€” email for personal, group URI for shared), `access_level` ("owner"/"readwrite"/"readonly"), `color` (hex string, optional), `is_primary` (boolean, only on primary calendars for each account). + +#### Watch Out + +- Requires Google Calendar connection in Settings β†’ Connectors (not connected by default) +- Returns **numeric string IDs** (e.g., "12", "21") used by `event_search_v0`, `event_create_v0`, etc. β€” these are NOT the email-based IDs from the Google Calendar API +- `is_primary` only appears on primary calendars β€” absent (not `false`) on non-primary calendars +- Multiple accounts supported: calendars from all connected Google accounts appear in one response +- **Browser/desktop:** Tool absent β€” Claude responds "I can only search Google Drive documents, not Google Calendar" + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Deferred, needs calendar connection | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 9 + +## `event_search_v0` + +| Property | Detail | +| --- | --- | +| Tool | `event_search_v0` | +| Version | v0 | +| Category | Calendar | +| Params | 5 | +| Permission | Calendar connection required | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "What's on my calendar today?" Β· "Any meetings tomorrow?" Β· "Show my schedule" | + +#### Overview + +Searches calendar events within a time range. Returns event IDs needed for update/delete operations. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `start_time` | string | No | ISO 8601 start of range | +| `end_time` | string | No | ISO 8601 end of range | +| `calendar_id` | string | No | Target calendar (from `calendar_search_v0`) | +| `include_all_day` | boolean | No | Include all-day events | +| `limit` | integer | No | Maximum results | + +#### Example Call + +```json +// Call +{ + "start_time": "2026-02-15T00:00:00+01:00", + "end_time": "2026-02-15T23:59:59+01:00", + "include_all_day": true +} + +// Response (confirmed β€” grouped by calendar) +{ + "status": "success", + "calendar_events": [ + { + "calendar_id": "12", + "calendar_name": "user@gmail.com", + "events": [ + { + "event_id": "1256", + "title": "Schema Test", + "start_time": "2026-02-16T11:00+01:00", + "end_time": "2026-02-16T11:30+01:00", + "status": "confirmed", + "organizer": "user@gmail.com", + "event_description": "", + "availability": "busy", + "location": "", + "nudges": [{"method": "email", "minutes_before": 20}] + } + ] + } + ] +} +``` + +**Response fields per event:** `event_id`, `calendar_id`, `calendar_name`, `title`, `start_time`, `end_time`, `status` ("confirmed" in most cases; "tentative" observed in some v1-created events), `organizer`, `event_description`, `availability` ("busy"/"free"), `location`, `nudges` (reminders array β€” conditional, appears on events with reminders set, not on imported/holiday events), plus conditional fields: `all_day` (boolean, all-day events only), `attendees` (array of emails, multi-person events only), `recurrence` (object, recurring events only). + +#### Watch Out + +- Claude typically calls `user_time_v0` first to get correct timezone offset +- Returns both `event_id` and `calendar_id` per event β€” both are needed for `event_update_v0` and `event_delete_v0` +- IDs are numeric strings (e.g., event_id `"1250"`, calendar_id `"12"`) +- Requires Google Calendar connection in Settings β†’ Connectors + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Deferred, needs calendar connection | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 10 + +## `event_create_v0` + +| Property | Detail | +| --- | --- | +| Tool | `event_create_v0` | +| Version | v0 | +| Category | Calendar | +| Params | 7 | +| Permission | Calendar connection required | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "Schedule a meeting for tomorrow at 2 PM" Β· "Block my calendar" Β· "Create an event" | + +#### Overview + +Creates a calendar event **draft** (UI template) for user confirmation. Unlike `event_create_v1` which creates events directly on the server, v0 presents a confirmation interface β€” the event is not committed until the user approves it in the UI. Returns only a string message, not event IDs. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `title` | string | Yes | Event title | +| `start_time` | string | Yes | ISO 8601 | +| `end_time` | string | No | ISO 8601 | +| `all_day` | boolean | No | All-day event | +| `description` | string | No | Event description | +| `location` | string | No | Location text | +| `recurrence` | object | No | Recurrence rules (see note below) | + +> **Recurrence:** The `recurrence` parameter works via `event_create_v0` using the three-field format: `{"frequency": "weekly", "human_readable_frequency": "weekly", "rrule": "FREQ=WEEKLY;WKST=MO;BYDAY=MO"}`. All three fields are required β€” subsets are rejected. Simple formats like `{"frequency": "weekly", "days_of_week": ["monday"]}` and bare RRULE strings are also rejected. The three-field format mirrors what `event_search_v0` returns for existing recurring events. +> +> **Confirmed RRULE variants tested via `event_create_v0`:** +> - `FREQ=WEEKLY;COUNT=3;WKST=MO;BYDAY=SU` β€” weekly on Sundays, 3 instances (confirmed: recurrence object persisted correctly) +> - `FREQ=MONTHLY;COUNT=3;WKST=MO;BYMONTHDAY=1` β€” monthly on the 1st, 3 instances (confirmed: instances appeared on Mar 1, Apr 1, May 1 with same event_id) +> - `FREQ=YEARLY;COUNT=2;WKST=MO` β€” yearly, 2 instances (confirmed: recurrence object persisted correctly) +> +> **Additional RRULE variants confirmed in existing calendar data:** `FREQ=MONTHLY;UNTIL=20270224;WKST=MO` (monthly with end date), `FREQ=MONTHLY;COUNT=52;WKST=MO` (monthly with count), `FREQ=MONTHLY;WKST=MO;BYMONTHDAY=25` (monthly on specific day), `FREQ=YEARLY;WKST=MO` (yearly), `FREQ=DAILY;COUNT=5;WKST=MO` (daily with count). +> +> `event_create_v1` does **not** have a `recurrence` parameter β€” recurring events can only be created via v0. + +#### Example Call + +```json +// Call +{ + "title": "Team standup", + "start_time": "2026-02-16T09:00:00+01:00", + "end_time": "2026-02-16T09:30:00+01:00", + "description": "Daily sync", + "location": "Zoom" +} + +// Response (confirmed β€” v0 is a draft tool) +"Event creation template has been created." +// Note: NO event IDs returned. Event requires user confirmation in UI. +// Use event_create_v1 for server-side creation with returned IDs. +``` + +#### Watch Out + +- **v0 is a DRAFT tool** β€” creates a UI template for user confirmation, not a server-side event. The event does NOT appear in `event_search_v0` until the user confirms it in the mobile UI. Once confirmed, the event is created with status **"confirmed"** and the `description` field persists correctly +- **No IDs returned** β€” v0 returns only a string message. Use `event_create_v1` for programmatic workflows where you need event IDs returned immediately +- **Description persists on v0** β€” unlike v1, the description passed to v0 appears correctly in `event_search_v0` after user confirmation +- **Location persists correctly** +- **Default calendar selection:** Without explicit `calendar_id`, may create on a secondary account rather than primary +- Claude typically calls `user_time_v0` first for correct timezone offset +- Requires Google Calendar connection in Settings β†’ Connectors + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Deferred, needs calendar connection | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 11 + +## `event_create_v1` + +| Property | Detail | +| --- | --- | +| Tool | `event_create_v1` | +| Version | v1 | +| Category | Calendar | +| Params | 1 (array) | +| Permission | Calendar connection required | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "Block my mornings for the next 3 days" Β· "Schedule meetings Mon/Wed/Fri" | + +#### Overview + +Batch event creation β€” multiple events in one call. Unlike `event_create_v0` (which creates a draft requiring user confirmation), **v1 creates events directly on the server** and returns structured IDs. This is the preferred tool for programmatic calendar operations. Events created via v1 have shown both **"confirmed"** and **"tentative"** status in different sessions β€” the status may depend on calendar provider or account configuration. Does **not** support the `recurrence` parameter. **Known bug:** the `description` field does not persist on v1-created events β€” `event_search_v0` returns it as empty. If description persistence matters, use v0 instead. **Default calendar:** v1 may default to a secondary account rather than the primary calendar β€” specify `calendar_id` explicitly when creating events across multiple accounts. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `new_events` | array | Yes | Array of event objects (same schema as `event_create_v0`) | + +#### Example Call + +```json +{ + "new_events": [ + {"title": "Deep work", "start_time": "2026-02-16T09:00:00+01:00", "end_time": "2026-02-16T10:00:00+01:00"}, + {"title": "Deep work", "start_time": "2026-02-17T09:00:00+01:00", "end_time": "2026-02-17T10:00:00+01:00"} + ] +} +``` + +#### Watch Out + +- Use this (not v0) when creating multiple events +- Each event in the array follows the same schema as `event_create_v0` + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Deferred, needs calendar connection | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 12 + +## `event_update_v0` + +| Property | Detail | +| --- | --- | +| Tool | `event_update_v0` | +| Version | v0 | +| Category | Calendar | +| Params | 1 (array) | +| Permission | Calendar connection required | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "Move my 2 PM meeting to 3 PM" Β· "Change the meeting title" | + +#### Overview + +Updates existing calendar events by ID. Follows the search-then-act pattern. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `event_updates` | array | Yes | Array of `{event_id, calendar_id, ...changed_fields}` | + +#### Example Call + +```json +// Call +{ + "event_updates": [ + { + "event_id": "1256", + "calendar_id": "12", + "start_time": "2026-02-16T11:30:00+01:00", + "end_time": "2026-02-16T12:00:00+01:00", + "location": "Milan office" + } + ] +} + +// Response (confirmed) +{ + "status": "success", + "update_results": [ + { + "calendar_id": "12", + "event_id": "1256" + } + ] +} +``` + +#### Watch Out + +- Requires `event_id` **and** `calendar_id` from `event_search_v0` β€” always search first, then update +- IDs are numeric strings (e.g., `"1250"`, `"12"`), not UUIDs +- Can update multiple events in one call +- **Can add attendees and nudges** β€” even though `event_create` doesn't support these, `event_update_v0` can add `attendees` (email array) and `nudges` (reminder array) to existing events +- **⚠️ Recurring events β€” `start_time` severs the chain:** Updating WITHOUT `start_time` safely applies changes to all instances. Updating WITH `start_time` (targeting one occurrence) **destroys the recurrence** β€” the targeted instance gets the update but all other instances permanently disappear. Never include `start_time` when updating a recurring event unless you intend to destroy the series + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Deferred, needs calendar connection | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 13 + +## `event_delete_v0` + +| Property | Detail | +| --- | --- | +| Tool | `event_delete_v0` | +| Version | v0 | +| Category | Calendar | +| Params | 1 (array) | +| Permission | Calendar connection required | +| Platform | Mobile App only (deferred via `tool_search`) | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "Cancel my 3 PM meeting" Β· "Delete the event" | + +#### Overview + +Deletes calendar events by ID. Typically used after `event_search_v0`. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `removed_events` | array | Yes | Array of event objects with `event_id` and `calendar_id` | +| `removed_events[].recurrence_span` | object | No | For recurring events: `{"option": "instance", "start_time": "ISO8601"}` to delete single instance *(untested)* | + +#### Example Call + +```json +// Call +{ + "removed_events": [ + {"event_id": "1256", "calendar_id": "12"} + ] +} + +// Response (confirmed) +{ + "status": "success", + "delete_results": [ + { + "calendar_id": "12", + "event_id": "1256" + } + ] +} +``` + +#### Watch Out + +- Destructive operation β€” Claude should confirm before deleting +- **⚠️ Recurring events:** Deleting a recurring event removes **all instances** (past and future), not just a single occurrence. The schema includes a `recurrence_span` parameter with an `"instance"` option and a `start_time` field for deleting a single occurrence, but this has not been tested +- Follows the search-then-act pattern: `event_search_v0` β†’ `event_delete_v0` +- Requires both `event_id` **and** `calendar_id` β€” get both from `event_search_v0` +- IDs are numeric strings, not UUIDs +- **Batch limit:** Maximum 2 events per delete call β€” calls with 3+ events are rejected with schema validation error +- **Not-found error format:** `{"error_type": "not_found", "message": "Event not found or already deleted"}` β€” returned per-event within the `delete_results` array +- **Duplicate risk:** If batch creation (`event_create_v1`) and individual creation (`event_create_v0`) run in the same session for similar events, duplicates can occur. Delete carefully by ID. + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Tool absent | +| Claude mobile | βœ… | Deferred, needs calendar connection | +| Claude desktop | ❌ | Tool absent | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 14 + +## `web_search` + +| Property | Detail | +| --- | --- | +| Tool | `web_search` | +| Version | Unversioned | +| Category | Search | +| Params | 1 | +| Permission | No | +| Platform | All | +| Docs | API version: `web_search_20250305` | +| Trigger phrases | Automatic for current events Β· "Search for..." Β· "Latest news about..." | + +#### Overview + +Web search returning top 10 results with snippets. The most frequently used tool. Short queries (1–6 words) perform best. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `query` | string | Yes | Search query | + +#### Example Call + +```json +{"query": "Serie A standings 2026"} +``` + +#### Watch Out + +- Short queries work best (1–6 words) +- No `site:` operator or advanced syntax by default +- Returns snippets only β€” use `web_fetch` for full articles +- API version (`web_search_20250305`) has different configuration + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | βœ…* | As `web_search_20250305` | +| Claude Code | ❌ | | + +--- + +### Tool Card 15 + +## `web_fetch` + +| Property | Detail | +| --- | --- | +| Tool | `web_fetch` | +| Version | Unversioned | +| Category | Search | +| Params | 1 required + 4 optional (+ 3 internal) | +| Permission | No | +| Platform | All | +| Docs | API version documented | +| Trigger phrases | Called after web_search Β· "Read that article" Β· "What does that page say?" | + +#### Overview + +Fetches full webpage content by URL. Used after `web_search` or with user-provided URLs. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `url` | string | Yes | Full URL with `https://` | +| `text_content_token_limit` | integer | No | Truncate text to approximately this many tokens | +| `web_fetch_pdf_extract_text` | boolean | No | If true, extract text from PDFs instead of raw bytes | +| `allowed_domains` | array | No | Only fetch URLs from these domains | +| `blocked_domains` | array | No | Never fetch URLs from these domains | + +*Additional internal parameters exist (`is_zdr`, `web_fetch_rate_limit_dark_launch`, `web_fetch_rate_limit_key`) but are operational and not user-relevant.* + +#### Example Call + +```json +{"url": "https://www.anthropic.com/news/claude-model-spec"} +``` + +#### Watch Out + +- Can only fetch URLs from `web_search` results or user-provided URLs β€” arbitrary access restricted +- Paywalled pages: silent truncation (page shell only, no article body) +- Auth-required pages (e.g., login walls): return structured 403 CLIENT_ERROR JSON rather than page content +- JavaScript-heavy sites may return minimal content +- URLs must include scheme (`https://`) +- Rate-limited on repeated fetches + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | βœ…* | Server-side | +| Claude Code | ❌ | | + +--- + +### Tool Card 16 + +## `image_search` + +| Property | Detail | +| --- | --- | +| Tool | `image_search` | +| Version | Unversioned | +| Category | Search | +| Params | 2 | +| Permission | No | +| Platform | All | +| Docs | None | +| Trigger phrases | "Show me pictures of..." Β· "What does X look like?" | + +#### Overview + +Web image search, returns images inline. Min 3 (enforced), max 5 (may return 4) results per call. Dimensions are mentioned in the tool schema but were not surfaced in testing. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `query` | string | Yes | 3–6 word descriptive query | +| `max_results` | integer | No | 3–5 (default 3) | + +#### Example Call + +```json +{"query": "capybara in hot spring", "max_results": 4} +``` + +#### Watch Out + +- Minimum 3 results, maximum 5 β€” can't request just 1 or 2 +- Content safety: no copyrighted characters, no celebrity photos, no graphic content +- 3–6 word queries work best + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 17 + +## `places_search` + +| Property | Detail | +| --- | --- | +| Tool | `places_search` | +| Version | Unversioned | +| Category | Search | +| Params | 4 | +| Permission | No | +| Platform | All | +| Docs | Feature known; internal name unknown publicly | +| Trigger phrases | "Best pizza near me" Β· "Coffee shops in Navigli" | + +#### Overview + +Google Places search. Up to 10 simultaneous queries, deduplicated results. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `queries` | array | Yes | 1–10 search queries | +| `location_bias_lat` | number | No | Latitude for location bias | +| `location_bias_lng` | number | No | Longitude for location bias | +| `location_bias_radius` | number | No | Radius in meters | + +#### Example Call + +```json +{ + "queries": [ + {"query": "best pizza Milan", "max_results": 3}, + {"query": "coffee shops Navigli Milan", "max_results": 3} + ], + "location_bias_lat": 45.4642, + "location_bias_lng": 9.1900 +} +``` + +#### Watch Out + +- Up to 10 queries in a single call +- Results deduplicated across queries +- Location bias from `user_location_v0` feeds into `location_bias_lat`/`lng` + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 18 + +## `places_map_display_v0` + +| Property | Detail | +| --- | --- | +| Tool | `places_map_display_v0` | +| Version | v0 | +| Category | Search | +| Params | 7 | +| Permission | No | +| Platform | All | +| Docs | None | +| Trigger phrases | "Show me on a map" Β· "Plan a walking tour" Β· "Map these locations" | + +#### Overview + +Interactive inline maps. Two modes: simple markers or full itinerary with multi-day routing. See Chapter 7. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `locations` | array | Mode A | Simple marker list | +| `days` | array | Mode B | Itinerary with day structure | +| `mode` | string | No | `"markers"` or `"itinerary"` β€” auto-inferred from `locations` vs `days` | +| `title` | string | No | Map title | +| `narrative` | string | No | Tour guide intro text | +| `travel_mode` | string | No | `"driving"`, `"walking"`, `"transit"`, `"bicycling"` | +| `show_route` | boolean | No | Show route lines (default: true for itinerary, false for markers) | + +**Location object fields:** `name` (required), `latitude` (required), `longitude` (required), `place_id` (optional), `notes` (optional), `arrival_time` (optional), `duration_minutes` (optional), `address` (optional) + +#### Example Call β€” Markers Mode + +```json +{ + "locations": [ + {"name": "Duomo di Milano", "latitude": 45.4641, "longitude": 9.1919, "place_id": "ChIJ..."}, + {"name": "Navigli", "latitude": 45.4494, "longitude": 9.1737, "place_id": "ChIJ..."} + ], + "title": "Milan Highlights" +} +``` + +#### Watch Out + +- Two distinct modes β€” use `locations` for markers, `days` for itineraries (not both) +- `place_id` from `places_search` enables full detail popups +- Copy `place_id` exactly β€” case-sensitive +- **Markers mode:** "Directions" triggers an "Open external link" dialog ("You're leaving Claude to visit an external link:") showing the full URL, with "Cancel" and "Open link" buttons +- **Itinerary mode:** "Open route" opens Google Maps directly with **no confirmation dialog** (inconsistent) +- Markers sidebar: rating badges, photo, reviews, category per location +- Itinerary: blue route lines, numbered stops, photo thumbnails, arrival times + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Interactive | +| Claude mobile | βœ… | Touch-optimized | +| Claude desktop | βœ… | Full | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 19 + +## `fetch_sports_data` + +| Property | Detail | +| --- | --- | +| Tool | `fetch_sports_data` | +| Version | Unversioned | +| Category | Search | +| Params | 4 | +| Permission | No | +| Platform | All | +| Docs | None | +| Trigger phrases | "NBA scores today" Β· "Serie A standings" Β· "How did the Lakers do?" | + +#### Overview + +Live scores, standings, and game stats across 20+ leagues via SportRadar. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `data_type` | string | Yes | `"scores"`, `"standings"`, `"game_stats"` | +| `league` | string | Yes | League identifier (e.g., `"nba"`, `"serie_a"`) | +| `team` | string | No | Filter by team name | +| `game_id` | string | No | For `game_stats` β€” get from `scores` results | + +#### Example Call + +```json +{"data_type": "standings", "league": "serie_a"} +``` + +#### Watch Out + +- Workflow: `scores` (get game IDs) β†’ `game_stats` (get details) +- `game_stats` not available for golf and NASCAR +- **60+ fields per player/team** in game_stats β€” includes zone shooting, situation stats, advanced metrics, and run tracking +- Game IDs are full UUIDs (e.g., `41344cbc-6bb9-4c0d-9be5-d1a4b45873b3`) +- League ID must be exact (e.g., `"serie_a"` not `"Serie A"`) + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 20 + +## `google_drive_search` + +| Property | Detail | +| --- | --- | +| Tool | `google_drive_search` | +| Version | Unversioned | +| Category | Search | +| Params | 6 | +| Permission | Google Drive connection required | +| Platform | All | +| Docs | None | +| Trigger phrases | "Find my Q3 report in Drive" Β· "Search Drive for budget docs" | + +#### Overview + +Google Drive search using native query syntax plus semantic filtering. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `api_query` | string | Yes | Google Drive query syntax | +| `semantic_query` | string | No | Natural language filter | +| `order_by` | string | No | Sort order | +| `page_size` | integer | No | Results count | +| `page_token` | string | No | Pagination token | +| `request_page_token` | boolean | No | Request next page token | + +#### Example Call + +```json +{ + "api_query": "name contains 'Q3' and mimeType = 'application/vnd.google-apps.document'", + "semantic_query": "quarterly sales presentation", + "order_by": "relevance desc" +} +``` + +#### Watch Out + +- `fullText` queries **require** `order_by: "relevance desc"` +- `name contains` is prefix-matching only +- `owners`, `writers`, `readers` require email addresses, not names +- Trashed documents never included +- **MIME type support limited** to `application/vnd.google-apps.document` and `application/vnd.google-apps.folder` β€” searching for Sheets or Slides returns empty silently (no error). Non-Doc files are **completely invisible** to the search tool regardless of query type β€” even name-based searches won't find them +- **Response format (confirmed):** Each result returns `source` (title), `document_content` (with indexed spans for citations), and metadata: `created_time`, `last_modified_by`, `last_modified_time`, `mime_type`, `owner`, `time_since_created`, `time_since_last_modified`, `url` +- **Content trimming:** Small documents return 100% content inline. Larger documents are trimmed (showing `percentage_of_full_document`) with a reminder to use `google_drive_fetch`. Very large documents return: "This file is too large" + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Needs Drive connection | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 21 + +## `google_drive_fetch` + +| Property | Detail | +| --- | --- | +| Tool | `google_drive_fetch` | +| Version | Unversioned | +| Category | Search | +| Params | 1 | +| Permission | Google Drive connection required | +| Platform | All | +| Docs | None | +| Trigger phrases | Called after google_drive_search Β· "Read that Google Doc" | + +#### Overview + +Fetches full Google Doc contents by document ID. Batch support via array. Google Docs only β€” not Sheets, not Slides. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `document_ids` | array | Yes | Array of Google Doc IDs | + +#### Example Call + +```json +{ + "document_ids": ["1i2xXxX913CGUTP2wugsPOn6mW7MaGRK", "1NFKKQjEV1pJuNcbO7WO0Vm8dJigFeEk"] +} +``` + +#### Watch Out + +- Google Docs only β€” Sheets and Slides not supported +- Non-Doc files return exact error: "The contents of this file cannot be retrieved. Only Google Docs are supported, and this document has a MIME type of [type]" β€” confirmed with `application/vnd.google-apps.folder` and `application/vnd.google-apps.spreadsheet`. **Google Slides** returns a different error: raw `error -32000` with a `drive:///` URI prefix instead of the friendly message +- Document ID is the string between `/d/` and `/edit` in the URL +- Batch: pass multiple IDs to read several docs at once + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Needs Drive connection | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 22 + +## `memory_user_edits` + +| Property | Detail | +| --- | --- | +| Tool | `memory_user_edits` | +| Version | Unversioned | +| Category | Memory | +| Params | 4 | +| Permission | No | +| Platform | All | +| Docs | [frmoretto/claude-memory-user-edits-guide](https://github.com/frmoretto/claude-memory-user-edits-guide) | +| Trigger phrases | "Remember that I work at..." Β· "What do you know about me?" Β· "Forget about my..." | + +#### Overview + +Persistent memory for facts about the user. Four commands: `view`, `add`, `remove`, `replace`. Works for **facts** not **behaviors**. 30 edits max, 200 chars each. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `command` | string | Yes | `"view"`, `"add"`, `"remove"`, `"replace"` | +| `control` | string | For `add` | Memory text (max 200 chars β€” server-enforced, schema says 500) | +| `line_number` | integer | For `remove`/`replace` | Line number (1-indexed) | +| `replacement` | string | For `replace` | New text | + +#### Example Call + +```json +{"command": "add", "control": "User works at Acme Corp as a product manager"} +``` + +```json +{"command": "replace", "line_number": 3, "replacement": "User moved from Milan to London"} +``` + +#### Watch Out + +- **Facts not behaviors**: "User is a vegetarian" works; "Always suggest vegetarian options" doesn't +- 30 edit limit β€” be concise; Claude rewrites verbose inputs +- **Hard limit: 200 characters per edit** β€” confirmed by testing. The parameter schema advertises a 500-character `maxLength` but the server enforces 200. Edits of 201+ characters return "Memory is too long" +- Edits permanent until explicitly removed +- Project-scoped: memories in one Project don't transfer to another + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 23 + +## `conversation_search` + +| Property | Detail | +| --- | --- | +| Tool | `conversation_search` | +| Version | Unversioned | +| Category | Memory | +| Params | 2 | +| Permission | No | +| Platform | All | +| Docs | Schema documented by Shlok Khemani (Sept 2025) | +| Trigger phrases | "Did we discuss X?" Β· "What did you say about..." Β· "Find our conversation about..." | + +#### Overview + +Topic-based search across past conversations. Keyword matching, project-scoped. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `query` | string | Yes | Search keywords | +| `max_results` | integer | No | 1–10 (default 5) | + +#### Example Call + +```json +{"query": "Python migration database", "max_results": 5} +``` + +#### Watch Out + +- Use **nouns**, not verbs: "Python migration" works; "discussed about" doesn't +- Project-scoped: only searches within current Project +- Recent conversations may not be indexed yet (slight delay) + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 24 + +## `recent_chats` + +| Property | Detail | +| --- | --- | +| Tool | `recent_chats` | +| Version | Unversioned | +| Category | Memory | +| Params | 4 | +| Permission | No | +| Platform | All | +| Docs | Schema documented by Shlok Khemani (Sept 2025) | +| Trigger phrases | "What did we talk about yesterday?" Β· "Show my recent chats" Β· "Continue last chat" | + +#### Overview + +Time-based chat retrieval. 1–20 chats per call, chronological or reverse. Pagination via `before`/`after`. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `n` | integer | No | 1–20 (default 3) | +| `sort_order` | string | No | `"desc"` (newest) or `"asc"` (oldest) | +| `before` | datetime | No | Chats before this time | +| `after` | datetime | No | Chats after this time | + +#### Example Call + +```json +{"n": 10, "sort_order": "desc", "after": "2026-02-08T00:00:00Z"} +``` + +#### Watch Out + +- Max 20 per call β€” use multiple calls with `before`/`after` pagination +- Project-scoped +- Use `sort_order: "asc"` with no filters for oldest conversations + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | | +| Claude mobile | βœ… | | +| Claude desktop | βœ… | | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 25 + +## `tool_search` + +| Property | Detail | +| --- | --- | +| Tool | `tool_search` | +| Version | Unversioned | +| Category | Meta | +| Params | 2 | +| Permission | No | +| Platform | Mobile (consumer tools) Β· Desktop (MCP tools only) Β· Browser: absent | +| Docs | None | +| Trigger phrases | Called internally when Claude needs a deferred tool Β· "What tools do you have?" | + +#### Overview + +The meta-tool: discovers other tools by keyword. Returns tool names with full parameter schemas. Powers the deferred loading mechanism. See Chapter 10. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `query` | string | Yes | Search keywords | +| `limit` | integer | No | 1–20 (default 5) | + +#### Example Call + +```json +{"query": "create display chart", "limit": 10} +``` + +#### Watch Out + +- **Browser:** Does not exist β€” no deferred loading system +- **Desktop App:** Exists but only discovers MCP tools (Chrome + Filesystem), not consumer deferred tools. With MCP active, it returns **all 32 MCP tools regardless of query** β€” it behaves as a "load everything" operation rather than a filtered search. Query keywords only affect ordering, not which tools appear +- **Mobile App:** Exists and discovers 11 consumer deferred tools (the ones documented in this book) +- Keyword-based with **fuzzy matching** β€” the same query may return different results across sessions. Tools bleed across unrelated queries, and some tools may require specific keywords to surface (e.g., `user_time_v0` may not appear for "user" but does for "time clock current") +- Can't find tools with unexpected names +- Deferred tools appear here; always-loaded tools do not +- Returns empty for always-loaded tools β€” expected, not an error +- Use broad queries first, then narrow + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | ❌ | Does not exist | +| Claude mobile | βœ… | Discovers consumer deferred tools | +| Claude desktop | βœ… | Discovers MCP tools only | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 26 + +## `weather_fetch` + +| Property | Detail | +| --- | --- | +| Tool | `weather_fetch` | +| Version | Unversioned | +| Category | Search | +| Params | 3 | +| Permission | No | +| Platform | Browser + Desktop only (NOT mobile) | +| Docs | None | +| Trigger phrases | "What's the weather in..." Β· "Should I bring an umbrella" Β· "Weather forecast for this week" | + +#### Overview + +Displays an interactive weather widget with current conditions and 5-day forecast. The widget is a polished gradient card that changes appearance based on weather conditions. See Chapter 7. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `latitude` | number | Yes | Location latitude | +| `longitude` | number | Yes | Location longitude | +| `location_name` | string | Yes | Human-readable name (e.g., "San Francisco, CA") | + +#### Example Call + +```json +{ + "latitude": 45.4642, + "longitude": 9.1900, + "location_name": "Milan, Lombardy, IT" +} +``` + +#### When Claude Uses It + +| Scenario | Example | +| --- | --- | +| Weather check | "What's the weather in Milan?" | +| Planning | "Should I bring an umbrella today?" | +| Travel | "What's the weather like in Tokyo this week?" | + +#### Watch Out + +- **API returns Fahrenheit only** β€” the underlying Google Weather API (`weather.googleapis.com`) always returns `unitsSystem=IMPERIAL`. There is no Β°C toggle at the API level +- **Widget displays raw API data** in Fahrenheit regardless of location or user locale +- Claude's **text summary** converts to Β°C/Β°F based on the queried city's convention (Β°C for London, Β°F for New York). This conversion is Claude's responsibility, not the API's +- System prompt says "use user's home location for units" but observed behavior follows the queried city's convention +- **Geographic coverage gaps:** The API returned a 404 for Tokyo coordinates in testing β€” not all global locations are supported. When the API fails, Claude falls back to web_search +- **Location label:** The API echoes back the `location_name` input plus a separate `country` field. Label duplication in the widget ("MILAN, LOMBARDY, IT, IT") is a front-end rendering artifact from concatenating these fields +- Widget features: blue/dark gradient card (changes by conditions), current temp + conditions, 5-day forecast with highs and precipitation %, "Weather data from Google" attribution +- **Mobile fallback:** `web_search` for weather data β€” text only, no widget + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Interactive widget | +| Claude mobile | ❌ | Fallback: web_search text | +| Claude desktop | βœ… | Interactive widget | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 27 + +## `recipe_display_v0` + +| Property | Detail | +| --- | --- | +| Tool | `recipe_display_v0` | +| Version | v0 | +| Category | Interaction | +| Params | 6 | +| Permission | No | +| Platform | Browser + Desktop only (NOT mobile) | +| Docs | None | +| Trigger phrases | "Show me a recipe for..." Β· "How do I make..." Β· "Recipe for tiramisu" | + +#### Overview + +Interactive recipe widget with adjustable servings, inline timers, and a full-screen cooking mode. The most feature-rich widget in the toolkit. See Chapter 7. + +#### Parameters + +| Parameter | Type | Required | Description | +| --- | --- | --- | --- | +| `title` | string | Yes | Recipe name | +| `ingredients` | array | Yes | Each: `{id, name, amount, unit}` | +| `steps` | array | Yes | Each: `{id, title, content, timer_seconds}` | +| `base_servings` | integer | No | Default servings (default 4) | +| `description` | string | No | Recipe tagline | +| `notes` | string | No | Tips and variations | + +#### Example Call + +```json +{ + "title": "Classic Tiramisu", + "description": "The Italian coffee-soaked dessert", + "base_servings": 6, + "ingredients": [ + {"id": "0001", "name": "mascarpone cheese", "amount": 500, "unit": "g"}, + {"id": "0002", "name": "egg yolks", "amount": 4, "unit": ""}, + {"id": "0003", "name": "sugar", "amount": 100, "unit": "g"}, + {"id": "0004", "name": "strong espresso", "amount": 300, "unit": "ml"}, + {"id": "0005", "name": "ladyfinger biscuits", "amount": 200, "unit": "g"}, + {"id": "0006", "name": "cocoa powder", "amount": 2, "unit": "tbsp"} + ], + "steps": [ + { + "id": "s1", + "title": "Make the cream", + "content": "Whisk {0002} with {0003} until pale. Fold in {0001}." + }, + { + "id": "s2", + "title": "Soak the biscuits", + "content": "Dip {0005} briefly into {0004}. Don't over-soak.", + "timer_seconds": 5 + }, + { + "id": "s3", + "title": "Assemble and chill", + "content": "Layer soaked biscuits and cream. Dust with {0006}. Refrigerate.", + "timer_seconds": 14400 + } + ], + "notes": "Best made a day ahead. Use room-temperature mascarpone for smoother cream." +} +``` + +#### When Claude Uses It + +| Scenario | Example | +| --- | --- | +| Recipe request | "Show me a recipe for tiramisu" | +| Cooking help | "How do I make carbonara?" | +| Meal planning | "What can I make with chicken and mushrooms?" | + +#### Watch Out + +- **Image carousel** at top β€” web-sourced with "Results from the web" attribution +- **Servings adjuster** (+/-) scales all ingredients proportionally +- **Cooking mode** ("Get cooking" button): full-screen step-by-step wizard with navigation +- **Timer states:** blue "Start" β†’ counting down β†’ green "Done!" β€” works in both views +- **Ingredient references:** Use `{ingredient_id}` in step content for inline amounts +- **Valid `unit` values:** `g`, `kg`, `ml`, `l`, `tsp`, `tbsp`, `cup`, `fl_oz`, `oz`, `lb`, `pinch`, `piece`, or empty string `""` for countable items (e.g., 4 eggs) +- Minor rounding in scaling (1.3Γ— may show 2.5 instead of 2.6) +- Grammar quirk: "1 teaspoons" (doesn't singularize) +- Default servings and images vary per generation, not per platform β€” Claude chooses the serving count (schema default is 4) +- **Mobile fallback:** plain text recipe (no widget, no cooking mode) + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Full widget + cooking mode | +| Claude mobile | ❌ | Fallback: plain text recipe | +| Claude desktop | βœ… | Full widget + cooking mode | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +### Tool Card 28 + +## `end_conversation` + +| Property | Detail | +| --- | --- | +| Tool | `end_conversation` | +| Version | Unversioned | +| Category | System | +| Params | 0 | +| Permission | No | +| Platform | All | +| Docs | None | +| Trigger phrases | None β€” never triggered by user requests | + +#### Overview + +Permanently ends the conversation, preventing any further messages. This is a safety tool used only in extreme cases of sustained abusive behavior β€” never for self-harm situations, crisis scenarios, or when a user might be at risk. Claude must issue explicit warnings before using it. + +#### Parameters + +This tool accepts no parameters. + +#### Example Call + +```json +// Call (no parameters) +{} +``` + +#### When Claude Uses It + +| Scenario | Example | +| --- | --- | +| Extreme abuse | Sustained harassment after multiple warnings | +| User request | User explicitly asks to end the conversation (requires confirmation) | + +#### Watch Out + +- **Never** used for self-harm or crisis situations β€” Claude stays engaged +- **Never** used for disagreements or difficult conversations +- Requires explicit warning to user before use +- Conversation **cannot be resumed** after use +- Claude never discusses this tool's existence proactively +- If user requests it, Claude asks for confirmation that the action is permanent + +#### Platform Availability + +| Platform | Available | Notes | +| --- | --- | --- | +| Claude.ai (web) | βœ… | Rarely used | +| Claude mobile | βœ… | Rarely used | +| Claude desktop | βœ… | Rarely used | +| Anthropic API | ❌ | | +| Claude Code | ❌ | | + +--- + +## N1AI β€” AI That Works for People + +This book is published by N1AI, a community-driven AI consultancy founded on a simple principle: AI should work for people, not the other way around. + +### What N1AI Does + +N1AI helps businesses discover, plan, and implement AI solutions that deliver measurable results. The approach covers the full journey: **AI Discovery** (auditing where AI can save time and money), **AI Strategy** (building a roadmap that fits your budget and team), **AI Execution** (deploying solutions that integrate with your current systems), **AI Training** (empowering your team to use AI confidently), and **AI Solutions** (building custom tools for your specific needs). N1AI partners with Anthropic, OpenAI, and Google to deliver solutions built on the best available technology. + +### The N1AI Community + +Beyond consulting, N1AI runs a 400+ member community connecting business owners, developers, and AI enthusiasts who are making AI work in the real world. Members get access to exclusive resources, workshops, expert Q&As, collaborative projects, and early access to tools and beta programs. No corporate jargon, no hype β€” just practical AI. + +The community is open to everyone: CEOs curious about AI, developers building solutions, or anyone who wants to understand what's possible. No experience required, just curiosity. + +### Values: H.E.A.R.T. + +N1AI leads with **H**uman first (people come first, always), **E**ntrepreneurship (act like owners), **A**ction (build, test, improve β€” fast), **R**esults (deliver, not just advise), and **T**ransparency (clear, honest, and open). + +Learn more: [n1ai.co](https://www.n1ai.co) Β· Join the community: [n1ai.co/community](https://www.n1ai.co/community/) Β· Contact: [n1ai.co/contacts](https://www.n1ai.co/contacts) + +--- + +## Bio + +Francesco Marinoni Moretto is AI Practice & Community Lead at N1AI, a 400+ member community of AI professionals. Before AI, he spent 18 years building technology adoption communities across Europe β€” starting as Italy's first CiviCRM evangelist in 2008, speaking at conferences in London and Manchester (95.5/100 audience rating), and scaling a SaaS platform to 1,600+ customers through founder-led community engagement. He studied Business & Management at Bocconi University. + +In the AI space, Francesco builds tools and writes research that fills gaps others ignore. His published work includes Hardstop (the only fail-closed safety plugin for Claude agentic tools, available on npm), Clarity Gate (epistemic verification for RAG systems), Stream Coding (a documentation-first development methodology), and ArXiParse (a scientific paper extraction platform live at arxiparse.org). His Claude Memory Research reached 68K views and 215 shares on Reddit β€” the first systematic documentation of Claude's undocumented memory system. + +He is an active speaker on the European AI circuit β€” Claude Code Meetup Milano, AI Tinkerers Milano, Aperitivo AI β€” and attended the Anthropic Builder Summit in London (October 2025). He has active CFPs submitted for AI Engineer Europe 2026 and PyTorch Conference Europe 2026. + +Connect: [linkedin.com/in/francesco-moretto](https://www.linkedin.com/in/francesco-moretto) +GitHub: [github.com/frmoretto](https://github.com/frmoretto) +N1AI: [n1ai.co](https://www.n1ai.co) Β· [github.com/n1-ai](https://github.com/n1-ai) +This book: [github.com/n1-ai/claude-hidden-toolkit](https://github.com/n1-ai/claude-hidden-toolkit) + +--- + +*Claude's Hidden Toolkit β€” Edition 1.3 β€” February 2026 β€” CC BY 4.0 β€” Francesco Marinoni Moretto, N1AI* diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f8ada8c --- /dev/null +++ b/LICENSE @@ -0,0 +1,24 @@ +Creative Commons Attribution 4.0 International License (CC BY 4.0) + +Copyright (c) 2026 Francesco Marinoni Moretto + +You are free to: + + Share β€” copy and redistribute the material in any medium or format for + any purpose, even commercially. + + Adapt β€” remix, transform, and build upon the material for any purpose, + even commercially. + +Under the following terms: + + Attribution β€” You must give appropriate credit, provide a link to the + license, and indicate if changes were made. You may do so in any + reasonable manner, but not in any way that suggests the licensor + endorses you or your use. + + No additional restrictions β€” You may not apply legal terms or + technological measures that legally restrict others from doing + anything the license permits. + +Full license text: https://creativecommons.org/licenses/by/4.0/legalcode diff --git a/README.md b/README.md new file mode 100644 index 0000000..40b0440 --- /dev/null +++ b/README.md @@ -0,0 +1,79 @@ +# Claude's Hidden Toolkit + +**The Definitive Guide to Claude.ai's Undocumented Internal Tools** + +*28 tools. Zero official documentation. Fully reverse-engineered.* + +--- + +## What Is This? + +Claude.ai ships with 28+ internal tools β€” capabilities that let Claude check the time, search your calendar, render interactive charts, draft emails with native app integration, find nearby restaurants, display them on a map, set alarms on your phone, and more. + +**Almost none of this is documented.** + +Anthropic's official docs cover the API. But the consumer product β€” claude.ai β€” has a rich, evolving toolkit that exists in a documentation void. This book fills that gap through systematic reverse-engineering across three platforms (browser, desktop app, mobile app). + +## Key Discoveries + +**Platform fragmentation is real.** Claude is not one product β€” it's three different tool sets: + +| Platform | Always-Loaded | tool_search | Deferred Tools | +|----------|:---:|:---:|:---:| +| Browser (claude.ai) | 21 | ❌ | None | +| Desktop App | 22 | MCP only | 32 (Chrome + Filesystem) | +| Mobile App | 20 | Consumer | 11 (alarm, timer, calendar, etc.) | + +**Every response format has been empirically confirmed** β€” no inferred schemas remain in Edition 1.3. + +## What's Inside + +| Chapter | Coverage | +|---------|----------| +| 1–2 | Architecture: two-tier loading, platform inventory, versioning | +| 3 | Context tools: `user_time_v0`, `user_location_v0` | +| 4 | Interaction widgets: `ask_user_input_v0`, `message_compose_v1` | +| 5 | Inline charts: `chart_display_v0` | +| 6 | Calendar & device: 6 calendar tools + alarms + timers | +| 7 | Search & data: web, images, places, maps, sports, Drive, weather, recipes | +| 8 | Memory: `memory_user_edits`, `conversation_search`, `recent_chats` | +| 9 | Computer use: bash, files, artifacts, the skill system | +| 10 | The meta-tool: `tool_search` and enumeration methodology | +| 11 | Complete tool reference index | +| 12 | MCP convergence and what comes next | +| Annex | 28 detailed tool cards with confirmed JSON schemas | + +## Read the Book + +- **[Claude_Hidden_Toolkit.md](Claude_Hidden_Toolkit.md)** β€” Full book, Markdown (~21,600 words) + +## Edition History + +| Edition | Date | Changes | +|---------|------|---------| +| 1.3 | Feb 2026 | Platform architecture chapter, 3 new tool cards (weather, recipe, end_conversation), cross-platform verification of all 28 cards, settings/connectors appendix, all response formats confirmed | +| 1.2 | Feb 2026 | 25 tool cards, discovery methodology, initial availability matrix | +| 1.0–1.1 | Feb 2026 | Initial discovery and documentation | + +## Prior Art & Credits + +This work builds on contributions from: **Shlok Khemani** (memory tool schemas, Sept 2025), **Simon Willison** (system prompt analysis), **Adversa AI** (security research, named `message_compose_v1`), **Federico Viticci / MacStories** (iOS tools and `_v0` naming convention discovery). + +## Who This Is For + +- **Power users** β€” learn exactly what to say to trigger hidden capabilities +- **Developers** β€” see what the consumer product does that the API doesn't +- **AI researchers** β€” a documented case study of production AI tool architecture + +## Author + +**Francesco Marinoni Moretto** β€” AI Practice & Community Lead, [N1AI](https://n1.ai) + +- LinkedIn: [linkedin.com/in/francesco-moretto](https://www.linkedin.com/in/francesco-moretto) +- GitHub: [github.com/frmoretto](https://github.com/frmoretto) + +## License + +CC BY 4.0 β€” You are free to share and adapt this work with attribution. + +This work is independent and not affiliated with Anthropic. Tools may change, be renamed, or be removed at any time. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..b2cbc81 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,46 @@ +# Security Policy + +## Scope + +This project documents Claude.ai's internal tools through reverse-engineering. While the book itself is documentation (not executable code), the subject matter touches on AI system internals, and discoveries may occasionally surface behaviors with security implications. + +## Reporting a Vulnerability + +If you discover a tool behavior that could be exploited to: + +- Bypass Claude's safety guardrails +- Access other users' data through shared storage or memory tools +- Exfiltrate sensitive information via tool parameters or responses +- Manipulate tool behavior through prompt injection in tool inputs +- Escalate permissions beyond intended scope + +**Please report it responsibly:** + +1. **Do NOT open a public Issue.** Security-relevant findings should not be disclosed publicly before they can be addressed. +2. **Email:** Contact the maintainer directly at the email listed on the [author's GitHub profile](https://github.com/frmoretto). +3. **Include:** + - Description of the behavior + - Steps to reproduce + - Platform(s) affected + - Potential impact assessment +4. **Also consider reporting to Anthropic directly** via their [responsible disclosure process](https://www.anthropic.com/responsible-disclosure-policy) β€” they are best positioned to fix tool-level vulnerabilities. + +## What This Project Will Do + +- Acknowledge receipt within 48 hours +- Assess whether the finding should be withheld from publication until Anthropic addresses it +- Coordinate with Anthropic if appropriate +- Credit the reporter (unless anonymity is requested) when the finding is eventually published + +## What This Project Will NOT Do + +- Publish exploit details before Anthropic has had reasonable time to respond +- Document tools or behaviors specifically designed to facilitate harm +- Provide instructions for bypassing safety systems + +## Supported Versions + +| Version | Supported | +|---------|-----------| +| 1.3 | Yes | +| < 1.3 | No β€” please reference the latest edition |