@Mentions & Tools

PebbleChat isn’t just a chat with a single AI model. It’s the front door to everything your organisation has built — every flow, agent, document store, skill, tool, LiveApp, and past conversation. You bring those into your current message by typing @ to open the Capabilities & Context menu, or by letting PebbleChat discover them automatically.

The Capabilities & Context menu

When you click the @ button in the composer (or type an @ in your message), the Capabilities & Context menu opens. Its sections are:

Pick a section and you’ll see every item of that type that’s visible to you. Select one and it appears in your message as a chip.

Auto (the default — let PebbleChat find the right thing)

This is often the right choice. You don’t need to know which document store contains HR policies or which agent handles procurement — you just ask the question in plain English, and PebbleChat uses asset discovery to find the best match.

Asset discovery works by embedding your message and comparing it to every discoverable asset in your workspace (flows, document stores, tools, agents). The top matches get injected into the response generation automatically.

You’ll see which assets were discovered in the Activity Stream on the response — each discovered asset is shown with its name, type, and a clickable link so you can jump to the underlying asset.

Making assets discoverable

For asset discovery to work, the builder of the asset (a flow owner, a document-store creator) needs to:

1. Mark the asset as Discoverable (a toggle on the asset’s settings panel)
2. Give it a clear description — PebbleChat matches against the description, so “Searches the HR handbook for leave, benefits, and policy questions” is much more useful than “HR bot”

Discoverable assets are discoverable only by people who have access to them — you won’t suddenly see things your workspace doesn’t own.

Document Stores

Document Stores are curated collections of documents that PebbleChat can search and cite. Think: your employee handbook, your product documentation, a set of contracts, your engineering runbooks.

When you @-mention a document store, PebbleChat runs a retrieval search against it, pulls the most relevant chunks, and uses them to answer your question — citing the source.

Example

@Pebble-Docs What's the current pricing for a 100-user organisation?

PebbleChat retrieves the relevant sections from the document store, generates a grounded answer, and shows you which chunks it used.

Each Document Store row in the menu shows its name and a short description — so you can tell “HR Policies” apart from “Engineering Runbooks” at a glance.

A Document Store can be built in PebbleFlows — any document loader, chunker, embedder, and vector store combination you can assemble there becomes a searchable Document Store here.

Past Chats

Past Chats is one of PebbleChat’s most underrated features. It lets you reference an earlier conversation as context for the current one — so you can start a fresh chat but still have PebbleChat remember something important from before.

When to use Past Chats

• “Continue where we left off.” You had a great research session yesterday and want to pick up in a new chat without losing the context.
• “Compare to that time.” You’re exploring a new approach and want PebbleChat to compare it to a previous analysis.
• “Summarise and move on.” Long conversations eventually outgrow the context window. Start a new chat, @ the old one, and PebbleChat condenses it for the new conversation.
• “Use my earlier prompt patterns.” Reference a chat where you developed a particular style or approach so the new chat inherits it.

Example

@Q2 Campaign Planning Based on what we decided in that session, draft a revised budget breakdown for Q3.

PebbleChat pulls in the referenced conversation, uses it to anchor the new response, and you continue with the same context as before.

Assistants

Assistants are the beginner-friendly side of PebbleFlows — a single AI agent with instructions, uploaded knowledge, and tool access. They’re great for reusable one-shot helpers (“translate to French”, “write a code review”, “draft a follow-up email”).

@-mention an Assistant and PebbleChat sends your message to it specifically instead of the currently selected model.

Flows

Flows are workflows built in PebbleFlows. Pick one from the Flows category and it’s inserted into your message as a chip with the flow’s readable name — whatever you type after the chip becomes the request the flow receives when you send the message.

Flows can receive the context of the conversation you launched them from, including any files you’ve attached in the chat. For that to work, the flow’s builder sets the flow’s Start node Input Type to Pebble Chat, which starts the workflow from the originating conversation context — your request, the recent messages, and your attached files all travel with it.

Inspect Pebble Flow

When a flow runs from your conversation, it appears as a row in the response’s Activity Stream with a PebbleFlow chip and the flow’s name. Click Inspect Pebble Flow on that row and the execution details drawer opens in place — the same node-by-node inspector used on the PebbleFlows Executions page — so you can see exactly what each step received and returned without leaving the conversation.

Flow-created conversations also appear in your chat history sidebar with a distinct flow icon and a readable title based on the flow’s name, so you can find and reopen them later.

Agents (Agentflows)

Agents are multi-step Agentflows built in PebbleFlows. They plan, call tools, branch based on results, and can take dozens of steps to complete a single task. When you @-mention an Agent, PebbleChat hands off to it entirely — you’ll see the full Agentflow execution in the Activity Stream.

Agents are best for complex, multi-step tasks where you want a specific workflow rather than a general-purpose chat response. Typical examples:

• A procurement agent that checks inventory, generates a PO, and files it
• A research agent that plans, searches, synthesises, and fact-checks
• A support triage agent that reads an incoming ticket, classifies it, and routes it

See the configuration panel for Agents:

Tools

Tools is the grab-bag category — anything that doesn’t fit the other buckets. Includes:

• Web search — the built-in live search
• Calculator, code interpreter — computational tools
• MCP tools — Model Context Protocol tools from connected MCP servers (Microsoft 365, Jira, custom integrations)
• Custom HTTP tools — one-off API calls your team has configured

Select a specific tool to tell PebbleChat to use that tool for your next message. Most of the time you won’t need to — PebbleChat selects tools automatically when it needs them — but explicit tool selection is useful when:

• You want to force a web search even for a simple question
• You want to require a specific MCP tool (e.g. a Jira integration) over a more general one
• You’re debugging why a particular tool isn’t being called

Skills

Skills are reusable prompt templates — a Persona plus optional supporting files, including Python code that runs in PebbleAI’s sandbox. They’re a first-class capability with their own top-level documentation:

• Auto-discovered at chat time alongside flows, agents, and document stores
• Can execute Python in the code execution sandbox to produce PDFs, spreadsheets, charts, and other files
• Output files land in your user file store and come back as download links in the chat
• Four scopes: platform, organisation, workspace, personal — with nearest-scope-wins precedence
• Byte-compatible with the Claude Code skills spec — you can import any public SKILL.md without modification
• 17 official Anthropic skills pre-imported (pdf, docx, xlsx, pptx, and more)

See PebbleChat → Skills for the full guide — what skills are, how to enable them, how to create your own, and how the security scanner and execution sandbox work.

LiveApps

LiveApps are governed, interactive mini-apps that open in the Canvas pane beside your conversation. The LiveApps category behaves differently from the rest of the menu: picking one opens the app immediately in Canvas — it doesn’t insert a mention chip or send a chat message. Only LiveApps enabled for you are listed.

See LiveApps for the full guide — what they are, how to pin them as shortcuts, and how to ask Pebble to open one by name.

Asset Discovery vs. explicit @-mention

A good pattern: start with discovery (just ask), check the Activity Stream to see what PebbleChat reached for. If the right asset wasn’t discovered, @-mention it explicitly next time, and consider asking the asset owner to improve the description.

Tips

• Mix and match. You can @-mention multiple things in one message — a document store, a skill, and an agent all at once.
• Write good asset descriptions. If you build flows, your descriptions directly determine whether users find them via discovery. Rewrite a vague description as a set of “when to use this” phrases.
• Check the Activity Stream. Every tool call, every discovered asset, every document retrieved is shown. It’s the best way to understand why PebbleChat answered the way it did.
• Use Past Chats for long projects. A month-long project can be broken into many smaller chats, each referencing the previous for continuity, instead of one giant thread the context window can’t hold.

Related

• Advanced Features → Activity Stream — how the Research & Tools panel shows what PebbleChat did
• LiveApps — the interactive apps you can open from the @ menu
• PebbleFlows — where flows, agents and document stores are built
• Admin → Asset Sharing — how admins control which assets are discoverable