Claude AI Slides in osFoundry: A Safe Research Workflow
Turn Claude’s web research into a sourced osFoundry slide deck. Learn the setup, tool flow, safeguards and limits before you automate Note updates.

Turn Claude's Research Into a Sourced osFoundry Slide Deck
A good AI research workflow shouldn't stop at a polished chat response. The output needs to land somewhere your team can review, reuse, and verify. With a custom Claude connector in osFoundry, Claude can research a topic, create a new Slides tab in a project Note, and save the web pages it relied on to that Note's Sources tab.
That separation matters. The research and reasoning happen in Claude. The slides and the source records live in the shared Note. Later, anyone who opens the Note can inspect the sources without digging through a chat transcript. And if you're updating existing work, you can keep earlier presentations untouched - just make sure the prompt and tool calls target the new tab precisely.
This guide walks through what the workflow does, how to set up the connection and Note, and how Claude's tool calls build the deck. It also covers the practical guardrails: approval prompts, version checks, source handling, file access, and what happens when you revoke access. The goal is a workable process - not a promise that AI research is automatically complete or correct.
What happens when Claude turns research into slides in osFoundry
The workflow links Claude's research activity to a specific Note in osFoundry - without moving the whole research process into osFoundry. Claude searches the web and does the reasoning in its own conversation. When it's ready to write, it uses the connected tools to read a Note, create a presentation tab, add the slides, and record the sources.
Here's how the responsibility breaks down:
| Task | Claude | osFoundry |
|---|---|---|
| Research | Searches and evaluates information in the Claude conversation | Does not see the searches or pages Claude reads |
| Select a Note | Chooses from Notes returned by the connected project | Exposes only Notes in projects available to the connection |
| Select a slide tab | Supplies the exact tab ID for a read or edit | Returns an ID for each tab instance, including multiple Slides tabs |
| Create a deck | Sends a slide plan, up to 20 slides per creation call | Creates a new Slides tab and returns its ID |
| Record sources | Supplies a title, HTTP or HTTPS URL, and description | Adds each source as a row in the Note's Sources tab |
| Authorize changes | Requests permission for tool calls that write data | Checks the user's current Note permissions on each call |
One key detail: osFoundry stores what Claude chooses to write. It isn't a record of everything Claude considered. The Note can contain the resulting slides and the source details, but the chat remains the record of Claude's research conversation itself.
This is useful for team work because the artifact and its evidence stay together. A colleague can open the presentation and verify the source rows in the Note, instead of relying on "Claude found it." It also makes gaps obvious: if a slide includes a factual claim but there's no matching source row, someone reviewing the deck can ask for one.
Also watch the difference between a tab type and a tab instance. A Note might already contain multiple presentations, all of type Slides. If you tell Claude to edit "the Slides tab," that's ambiguous. The connector returns a separate ID for each tab, and Claude needs to use the exact ID it receives for the new deck when it later makes edits.
How do you prepare a Note and connection?
This workflow assumes you've already created a custom Claude connection in osFoundry, added the osFoundry MCP connector to Claude, and attached the connection to a project. The Note also has to be in that same project.
If a Note exists only on your current device (no cloud copy), the project connection can't access it.
Put the Note in the connected project
Open the Note and its right-hand panel, then go to Config → Settings. If the Project field shows Add to project, select the project tied to the Claude connection. This is an access requirement, not just an organizational preference - the connection can only list and work with Notes available through its project.
Before you ask Claude to write anything, confirm you're targeting the shared project Note you actually want to use. Similar names can cause avoidable mistakes, especially when teams keep different research Notes for different quarters, products, or clients.
Check the tools Claude can use
In osFoundry, open the key icon, select Connected, choose the Claude connection, and review its Tools list. For this workflow, Claude needs read access to inspect the Note and write access to create/update the presentation and add sources.
The relevant tools are:
- Read:
list_note_tabs,read_note_tab,list_note_attachments - Write:
create_note_tab,edit_note_tab,add_note_source
By default, supported tools are enabled. If you disable the write tools and save, Claude can still read the Note and list sources - but it can't create a deck or add source rows. That's a valid read-only setup; it just can't complete the workflow described here.
Make the prompt identify the target and the intended change
Your prompt should include the Note name, the tab Claude should read, the name of the new deck, and any existing decks it must leave alone. Ask for a new tab, not an update to an existing presentation. Naming the Sources tab also makes the destination for evidence explicit.
Example prompt:
Research how pricing for major large language model APIs changed this quarter. Then, in osFoundry, open the Note "Q4 pricing research." First read the "Research notes" tab and the existing Sources. Create a NEW Slides tab called "API price cuts" with about five slides, ending with a Sources slide. Add every page you relied on to the Note's Sources tab. Do not change the "Pricing" or "Launch status" presentations.
This gives Claude a clear sequence, a specific target, and boundaries. It still doesn't guarantee the research is comprehensive - so you'll want to review the findings and the sources yourself, especially when prices, dates, or product terms may shift.
How does the research-to-slides workflow work?
A solid run follows a sequence of explicit reads and writes. Claude first identifies the Note's tabs, reads the relevant context (including existing sources), then creates a new presentation tab, verifies the returned tab ID, adds a final Sources slide if needed, and records the pages it used.
Read before writing
Claude calls list_note_tabs to retrieve the Note's tabs and their IDs. In this example, the Note already has a Markdown tab called "Research notes" and two Slides tabs called "Pricing" and "Launch status." Claude reads the research notes using the tab ID, then checks what sources are already attached.
That initial pass helps reduce two common problems: creating a deck without using the team's existing context, and adding duplicate sources without checking what's already in the Note. It also captures the current Note version. Later, that version is used in write calls so osFoundry can detect changes between the read and the write.
Create the deck as a new tab
Claude sends a slide plan to create_note_tab, including the Note ID, the Slides tab type, a label, and the slide content. The call can include up to 20 slides. In the example, the plan includes five slides: an overview of quarterly API prices, a comparison of price cuts, cached-input pricing, implications for the team's plan, and open questions.
The tool creates a new tab and returns its ID. Claude should use that exact ID for any later reads or edits. It shouldn't guess the destination based on tab position or the fact that another tab also has the Slides type.
The creation call is also where you define slide order. A later slide_add operation adds a slide to the targeted presentation, but its schema doesn't include a position field. If the Sources slide must be last, plan for that up front - or check after adding slides.
Add and verify the source record
After creation, Claude can read the new tab to confirm what was saved. It can then add a final Sources slide with edit_note_tab and add each researched page to the Note using add_note_source. Each source record includes a title, an HTTP or HTTPS URL, and a short description written by Claude (for example, which slide the page supports).
osFoundry's Recent activity view records tool calls, decisions, and timestamps. It's an operational log of what Claude did in the Note, while the chat transcript shows the bigger research conversation. Neither replaces your responsibility to verify that the sources actually support the slide claims.
When everything's done, you should be able to spot a clear result: a newly named Slides tab, the existing presentations unchanged, and one source row per page Claude relied on. Those source rows stay editable in the app. You can open them, update or remove them, and copy the direct record link from a row for use inside the slide text.
What are the safety boundaries and trade-offs?
This integration is built to make specific Note changes, not to give Claude unrestricted control over a workspace. The boundaries are helpful, but they don't remove the need for review. Knowing what the connector can and can't do is part of keeping the workflow reliable.
Writes are permissioned and version-aware
Claude asks for your approval before each write tool call. osFoundry also checks your current permissions to modify the Note every time a call is made. So you're seeing and approving actions rather than granting one big, open-ended instruction.
Writes also include the Note version Claude last read. If someone edits the Note in the meantime, osFoundry can reject the stale write. Claude then has to read the latest version and try again. This prevents an automation from silently applying changes to outdated content, though it can add an extra step when multiple people are working at once.
New-tab creation protects existing presentations
create_note_tab creates a new Slides (or Sheet) tab; it doesn't take over an existing presentation. Later slide operations use the specific tab ID Claude received. This supports a clean review pattern: keep the original deck intact and generate a separate version for AI-assisted analysis.
But that protection only works if the targeting is correct. Your prompt should name the new tab and the presentations that must remain untouched. Claude then needs to use the returned ID for every subsequent operation. The ID is the technical safeguard; the prompt defines the task boundary.
Sources are recorded, but research itself stays in Claude
osFoundry only receives what Claude writes: the slide content and the source metadata. It doesn't see Claude's search history, and it doesn't independently verify the pages Claude reads. A source entry makes evidence easier to inspect - but it doesn't automatically prove that a claim is accurate, that the page is the right authority, or that every relevant page made it into the deck.
For anything consequential, double-check key numbers against the original source and verify dates, units, and pricing conditions. API pricing can vary by model, region, volume tier, and input type. A slide that compresses those details may be easy to present, but it can still be misleading if your comparison criteria aren't spelled out.
File access is deliberately limited
list_note_attachments returns metadata for Files and Sources, with up to 50 items per page. It doesn't return file contents or download links. add_note_source takes HTTP and HTTPS links, not arbitrary files. Editing or deleting sources and files remains a human task in the desktop app; edit_note_tab doesn't change attachments.
That's a meaningful security boundary. A download link pasted into a chat could be forwarded or remain usable even after you revoke a connection. The connector's source workflow instead records normal web URLs and leaves file management inside the application.
Retries should not create duplicates
Each write uses an idempotency key. If Claude doesn't get a response and retries the same operation with the same key, osFoundry returns the original result instead of creating a second tab or duplicate source row. This makes recovery from lost responses safer - but it depends on reusing the same key for the same operation, rather than generating a new one on every retry.
You can also withdraw access. Remove the Note from the connected project, remove the project from the connection, or revoke the connection itself, and Claude's next access attempt is denied. So Claude's actions are bounded by both the tools you enable and the project-level access you maintain.
Conclusion
Claude and osFoundry handle different parts of the job: Claude researches and drafts; osFoundry provides a shared Note where the slides and their source rows can be reviewed. The workflow works best when the Note is in the connected project, write tools are enabled deliberately, and the prompt asks for a clearly named new tab.
Treat the returned tab ID, version checks, approval prompts, and source rows as part of the operating process, not just implementation details. They help keep AI-assisted work traceable and reduce the risk of overwriting a teammate's deck. Before you share the result, review the claims and sources yourself. Automation can turn research into a usable artifact - but whether that artifact is reliable still comes down to your judgment.