Forem: Tim Gaul

Beyond Deadwoodworks: How Claude Code Skills Super-charge MCP Servers and Everyday Workflows

Tim Gaul — Wed, 19 Nov 2025 03:37:43 +0000

You've probably heard about AI assistants that can "use tools." Maybe you've even set up an MCP server or two. But here's the question nobody's asking: why do they work perfectly one day and completely miss the mark the next?

I'll tell you why: you're giving Claude access to tools, but you're not giving it the playbook.

That's what skills do. They turn "Claude can technically do this if I phrase it right" into "Claude does this reliably, every single time, without me babysitting it."

This isn't just for developers—though if you are one, you'll love this. This is for anyone who's tired of re-explaining the same workflow, watching AI miss obvious steps, or wondering why yesterday's perfect prompt doesn't work today.

In this article, you'll learn what skills actually are, see real-world examples across different teams, understand the difference between skills and MCP servers (they're not the same thing), and build something you can use today. Screenshots and working code ahead—grab a coffee. ☕️

Why Skills Matter (And Why MCP Servers Alone Aren't Enough)

Here's the thing everyone gets wrong at first: they think MCP servers are the solution. You set them up, Claude can access your tools, problem solved.

Except it's not solved. You still have to explain what you want every single time. The phrasing matters. The order matters. Miss a step? Claude misses it too.

Without skills, you're a manager who has to micromanage every task.

With skills, you write the instructions once, and Claude follows them forever.

What skills actually give you:

Predictable, consistent behaviour → No more "why did it skip that step today?" moments

Reusable logic that scales → Build once, use everywhere

Safety and control → You define the guardrails, not hope for the best

Evolve without rewiring → Update the skill, not your entire stack

💡 The shift: From "Does Claude understand what I need?" to "Claude already knows what to do."

MCP Server vs Skill—What's Actually Happening Here

Alright, let's clear up the confusion. A lot of people think MCP servers and skills are the same thing. They're not. Here's the difference, and why it matters:

Component	What it does	When you need it
MCP server	Gives Claude access to your files, APIs, databases, external systems	When Claude needs to reach outside itself to get data or take actions
Skill	Defines how Claude uses those tools—what order, what validation, what to do when things go wrong	When you want Claude to follow a specific workflow reliably

Here's the mental model:

MCP server = "Claude, here are the keys to the filing cabinet."

Skill = "Claude, here's exactly how to organise what's inside."

The MCP Server provides access to tools, while the Skill orchestrates how those tools are used to deliver consistent, predictable results.

You need both. MCP gives the access. Skills give the logic.

What happens if you only have MCP?

Claude can technically access everything, but you're counting on it to figure out the right sequence every time. Sometimes it nails it. Sometimes it doesn't. You're rolling the dice.

What happens if you only have a skill?

Nothing. The skill is calling tools that don't exist. It's like writing a perfect recipe but having no ingredients.

What happens when you have both?

Magic. Claude knows what it can access and exactly how to use it. Every. Single. Time.

⚠️ Common mistake: People build an MCP server, see that Claude can use the tools, and think they're done. Then they wonder why results are inconsistent. The MCP server isn't the finish line—it's the starting line.

How Real Teams Are Actually Using This

Let's get out of theory and into what this looks like when people use it every day.

📸 Content & Marketing Teams

The workflow: Upload images, videos, docs → Skill auto-tags everything → Files are organised and searchable

What changed: No one's manually tagging 47 product photos anymore.

🛠️ Product & Engineering

The workflow: New tickets → Skill triages, generates test stubs, flags violations → Team focuses on real work

What changed: The skill is the teammate who never forgets.

💬 Customer Support & Success

The workflow: User report → Skill classifies, pulls context, drafts response or escalates

What changed: Support teams stop reacting and start operating.

⚙️ Internal Ops & Automation

The workflow: Audit logs, error reports, health checks → Skill handles routine maintenance

What changed: Your team focuses on actual problems, not routine checks.

What's the common thread?

You're not asking Claude to help you. You're giving Claude responsibility to do it without you.

That shift—from assistant to operator—is where the real value lives.

Let's Build Something: Auto-Tagging Files in Under 20 Minutes

Enough theory. Let's build a skill you can actually use.

This one's simple but meaningful: you point Claude at a folder, it reads your files, analyses what they are, and tags them automatically. Useful for any team. Any workflow.

By the end, you'll have something working that you can adapt to your own needs.

Example file upload interface showing various document types ready for automatic tagging and categorisation.

Step 1—Understand What Tools You Just Unlocked (1 minute)

With Claude Code's built-in filesystem MCP, you have these abilities:

Tool	What it does
`list_directory`	See what files are in a folder
`read_file`	Read the content of a file
`write_file`	Write to a file (we won't use this today)

That's it. Simple, focused, useful.

Claude Code's built-in filesystem tools for reading files and listing directories.

Step 2—Write the Skill (5 minutes)

Here's where you build the workflow. Skills live in a .claude folder in your project.

Your folder structure should look like this:

your-project/
├── .claude/
│   └── skills/
│       └── auto-tag-files/
│           └── SKILL.md
└── uploads/
    ├── file1.png
    ├── file2.pdf
    └── file3.mp4

Create a file at .claude/skills/auto-tag-files/SKILL.md and paste this:

---
name: auto-tag-files
description: Automatically tag and categorise files from the uploads folder. Use this when the user asks to tag files, organise uploads, categorise recent files, or analyse uploaded content.
allowed-tools: Bash, Read, Glob
---

# Auto-Tag Files

Automatically analyse and tag files from the uploads directory.

## Instructions

When this skill is activated:

1. Use Glob to find all files in the ./uploads directory
2. For each file found:
   - Use Read to examine the file content (for text/code files) or Read to view images/PDFs visually
   - Analyze the content to determine:
     - File type (image/document/video/code/data)
     - 3-5 meaningful keywords/tags based on the content
   - Create a structured summary with filename, type, and tags
3. Present all results in a clear, organised format (JSON or markdown table)

## Analysis Guidelines

- **Images**: Describe visual content, subjects, style, purpose
- **Documents**: Extract key topics, themes, purpose, audience
- **Videos**: Note subject matter, format, likely purpose
- **Code**: Identify language, frameworks, purpose, key functionality
- **Data**: Determine format, structure, domain, use case

## Output Format

Present results as a JSON array or markdown table:

[
  {
    "filename": "banner.png",
    "type": "image",
    "tags": ["branding", "header", "design", "marketing", "visual"]
  }
]

## Limits

- Process up to 10 files by default
- If the user specifies a limit, honor that number
- For large files, analyse a representative sample

What this does, step by step:

Frontmatter: Defines the skill name, description, and allowed tools (Bash, Read, Glob)
Instructions: Tells Claude exactly what to do when the skill is activated
Analysis Guidelines: Provides specific guidance for different file types
Output Format: Specifies how results should be structured (JSON or markdown table)
Limits: Sets reasonable boundaries (10 files by default, configurable)

This is your workflow, locked in. Claude follows these instructions every time, using the allowed tools to get consistent, predictable results.

Step 3—Use It Like a Human (30 seconds)

Open Claude and just type:

"Tag my last 3 uploads"

"Auto-tag my recent files"

That's it. Claude sees the skill is available and runs it. No JSON. No configuration. Just talk to it.

What happens behind the scenes:

Skill lists your 3 most recent files
Reads the content of each one
Claude analyses what type of file it is and what tags make sense
You get back a clean, structured list

Claude Code interface showing the auto-tag-files skill being called and displaying the structured tagging results.

Step 4—What You Actually Get Back

Here's what the output looks like:

[
  {
    "filename": "banner.png",
    "type": "image",
    "tags": ["marketing", "branding", "technology", "abstract-design", "header"]
  },
  {
    "filename": "pitch_deck.pdf",
    "type": "document",
    "tags": ["business", "presentation", "investment", "market-strategy", "startup"]
  },
  {
    "filename": "demo_video.mp4",
    "type": "video",
    "tags": ["demonstration", "product", "presentation", "marketing", "promotional"]
  }
]

Why this matters:

For non-technical users: "I just asked it to tag my files and it worked."

For developers: Clean, structured data you can pipe into other systems.

For teams: Everyone gets consistent tagging without manual work.

You're not just getting suggestions. You're getting reliable, repeatable results.

💡 Try this now: Drop 3 random files in your uploads folder and run the skill. See what happens. Then go tweak the skill to add more tags, change the format, or filter by file type. That's the power of having the logic in one place.

Handling Video Files with Scripts and Examples

⚙️ Advanced Technique

This section covers extending skills with custom scripts and examples files. If you're just getting started, the basic skill above works great—come back to this when you're ready to level up.

When you run the auto-tag skill on video files, you might notice something like this:

● Read(uploads/demo_video.mp4)
  ⎿  Error reading file

This is expected. Claude can't directly "read" binary video files the way it reads text documents or analyses images. Video files need special handling.

The Solution: Extract Frames First

Here's where skills get powerful. Instead of giving up on videos, we can:

Use a bash script to extract frames from videos (1 frame per second)
Store those frames in a folder matching the video name
Analyze the frames to understand what's in the video
Tag the video based on that analysis

This demonstrates two advanced skill features:

Scripts (scripts/ folder) - External tools your skill can call
Examples (EXAMPLES.md) - Reference documentation for complex workflows

Setting Up the Advanced Video Tagging

First, create the proper skill structure with scripts:

mkdir -p .claude/skills/auto-tag-files/scripts

Your folder structure will now look like:

your-project/
├── .claude/
│   └── skills/
│       └── auto-tag-files/
│           ├── SKILL.md
│           ├── EXAMPLES.md (new)
│           └── scripts/
│               └── extract_video_frames.sh (new)
└── uploads/
    ├── file1.png
    ├── file2.pdf
    └── demo_video.mp4

Create the Frame Extraction Script

Create .claude/skills/auto-tag-files/scripts/extract_video_frames.sh:

#!/usr/bin/env bash
set -euo pipefail

# Extract 1 frame per second from video files in uploads/
# Usage: ./scripts/extract_video_frames.sh <video_filename>

VIDEO_FILE="${1}"
VIDEO_NAME=$(basename "$VIDEO_FILE" | sed 's/\.[^.]*$//')
OUTPUT_DIR="uploads/$VIDEO_NAME"

if ! command -v ffmpeg >/dev/null 2>&1; then
  echo "ERROR: ffmpeg is not installed. Install with: brew install ffmpeg" >&2
  exit 1
fi

mkdir -p "$OUTPUT_DIR"

echo "Extracting frames from: $VIDEO_FILE → $OUTPUT_DIR"

# Extract 1 frame per second, max 10 frames
ffmpeg -y -i "$VIDEO_FILE" \
  -vf "fps=1,scale=640:-1" \
  -frames:v 10 \
  "$OUTPUT_DIR/frame_%02d.jpg" 2>/dev/null

echo "✓ Extracted frames to: $OUTPUT_DIR/"

Make it executable:

chmod +x .claude/skills/auto-tag-files/scripts/extract_video_frames.sh

Add the Examples File

Create .claude/skills/auto-tag-files/EXAMPLES.md:

# Auto-Tag Files Skill – Examples

## Example 1: Tagging Mixed Files (Including Videos)

When you have videos in your uploads folder:

**Step 1:** List all files in uploads/

ls uploads/
# demo_video.mp4, banner.png, pitch_deck.pdf

**Step 2:** For video files, extract frames first:

./scripts/extract_video_frames.sh uploads/demo_video.mp4

This creates: `uploads/demo_video/frame_01.jpg`, `frame_02.jpg`, etc.

**Step 3:** Analyze frames to understand video content:

- Read each extracted frame image
- Identify objects, actions, settings, style
- Generate tags based on visual analysis

**Step 4:** Tag the video based on frame analysis:

{
  "filename": "demo_video.mp4",
  "type": "video",
  "tags": ["product-demo", "software", "tutorial", "screen-recording", "presentation"]
}

## Example 2: Batch Processing with Videos

# Process all files, automatically handling videos
"Tag all my uploads including videos"

The skill will:
1. Detect video files by extension (.mp4, .mov, .avi, .mkv)
2. Run frame extraction script automatically
3. Analyze extracted frames
4. Tag video based on visual content
5. Clean up temporary frames after analysis

Update Your SKILL.md

Now update the main skill file to handle videos. Add this section after the "Analysis Guidelines":

## Video File Handling

Videos cannot be read directly. For video files:

1. Detect video files by extension (.mp4, .mov, .avi, .mkv)
2. Run the frame extraction script:
   `./scripts/extract_video_frames.sh uploads/[video_filename]`
3. Analyze the extracted frames from `uploads/[video_name]/frame_*.jpg`
4. Generate tags based on what you see across the frames
5. After tagging, optionally remove the frames folder to save space

**Note**: Requires `ffmpeg` to be installed. If not available, tag videos as "video-content-unknown" and note this in output.

How It Works in Practice

Now when you run the skill:

"Tag my files including the demo video"

Claude Code automatically detecting a video file, extracting frames, and generating meaningful tags based on the visual content analysis.

Claude will:

See demo_video.mp4 in uploads
Recognize it's a video file
Execute the bash script to extract frames
Read and analyse the extracted frames
Generate meaningful tags based on visual content
Return structured results including the video

Before (without scripts):

Error reading file: demo_video.mp4
Type: unknown

After (with scripts):

{
  "filename": "demo_video.mp4",
  "type": "video",
  "tags": ["product-demo", "smart-home", "aura-smart-hub", "presentation", "technology"]
}

Why This Matters

This isn't just about videos. You've now learned:

Scripts extend what skills can do beyond Claude's built-in tools
Examples files document complex workflows for future reference
Skills can orchestrate external tools, not just use MCP servers
The pattern scales to PDFs requiring OCR, audio transcription, data processing, etc.

You're not limited to what Claude can do natively. You're teaching it how to use the right tool for each job.

💡 Try this: Drop a video in your uploads folder and run the skill. Watch it extract frames, analyse them, and return structured tags. Then look in uploads/[video_name]/ to see the frames it analysed.

What Just Changed

You didn't just build a one-off automation. You gave Claude a reusable capability that works the same way every time you invoke it.

Before skills:

❌ Open Claude

❌ Explain what you want

❌ Hope it understands

❌ Check if it worked

❌ Repeat tomorrow

After skills:

✅ "Tag my files"

✅ Done

The difference between those two experiences? That's what makes skills worth understanding.

What's Next

Skills in Claude Code aren't a novelty—they're a different way of working with AI. Instead of asking "Can Claude help me with this?" you move to "Claude already knows how to do this."

You're not building throwaway scripts. You're creating persistent, reliable workflows. Whether you're in engineering, marketing, ops, or somewhere in between, this unlocks something real.

Now you've got the concept. You've seen the use-cases. You understand the MCP vs Skills distinction. And you've built something working that you can adapt.

Next step? Drop in your screenshots, tweak the skill for your actual workflow, and start building things your team will actually use.

Because the difference between "cool demo" and "thing I use every day" is reliability. And that's what skills give you.

Read the full walkthrough and related posts on my blog: Beyond Deadwoodworks. It dives into Claude Code skills, MCP servers, and practical automations (auto-tagging, video handling) so you can move from brittle prompts to reliable workflows.

Connect on LinkedIn and share your perspective: what workflow would you hand over to Claude today?

OpenAI Agent Builder: The No-Code Way to Put AI on Your Website

Tim Gaul — Tue, 14 Oct 2025 10:19:22 +0000

Most people think building an AI chatbot for your website requires a development team, a bunch of API calls, and weeks of testing. That was true six months ago. Then OpenAI launched Agent Builder, and suddenly you can build a working AI agent—one that reads from your knowledge base, follows your instructions, and deploys to your website—with minimal code in about 15 minutes.

What is OpenAI Agent Builder?

Agent Builder is OpenAI's visual tool for creating AI agents—basically custom ChatGPTs that can actually do things instead of just suggesting them.

Think of it like this:

Regular ChatGPT: You ask a question, it gives you an answer based on training data
Custom GPTs: You add instructions and documents, it remembers your context
Agent Builder: You connect tools and build workflows, it can take actions on your behalf

Here's the killer feature: Agent Builder gives you a GUI for connecting your agent to external services like Notion, Slack, Google Drive, or your own APIs. You're not writing integration code—you're just clicking checkboxes and configuring fields.

It's like Zapier met ChatGPT and had a very capable child.

The visual workflow you see in Agent Builder isn't just for show—it's actually how you design your agent's behavior. Want your agent to check a database, process the results, then send a formatted message? Just drag those nodes onto the canvas and connect them.

Why This Matters (And Why I'm Writing About It)

I've spent the last few months building AI automation workflows using ChatGPT custom actions, Claude MCP, and various API integrations. They all work, but they all have friction.

Agent Builder removes most of that friction.

You don't need to:

Write authentication code
Handle API responses
Parse JSON
Deal with rate limits
Deploy infrastructure
Manage secrets (well, mostly)

You just connect things through a visual interface and OpenAI handles the plumbing.

That's transformative for small businesses and solo developers who want AI capabilities but don't want to become integration specialists.

What We're Building Today

To show you how Agent Builder actually works in practice, we're going to build a customer support chatbot for a fictional adventure travel company called TrekWise.

Why this example? Because it demonstrates the three core capabilities of Agent Builder:

Data retrieval: Reading from external sources (we'll use Notion)
Intelligent processing: Understanding questions and finding relevant answers (RAG pattern)
User interface: Deploying as a chat widget that anyone can interact with

The company is fictional, but the demo is real and fully functional. You can see the working TrekWise chatbot at trekwise-adventure-blueprint.pages.dev and even clone the repository from github.com/FourixAI/trekwise-adventure-blueprint to see how it all works under the hood.

By the end, you'll have a working agent that:

Reads from a Notion page containing FAQs and product info
Answers customer questions intelligently
Lives on your website as a clickable chat widget
Updates automatically when you edit your Notion page

All built through Agent Builder's visual interface. Minimal code until the very last step (deploying to your site).

The Architecture: How Agent Builder Thinks

Before we start clicking buttons, let's understand what Agent Builder is actually doing under the hood. This will make the GUI make more sense.

An agent in Agent Builder has three core components:

1. Instructions (The Brain)
This is where you tell your agent what its job is and how to behave. Think of it as writing a job description for an employee who's very literal and incredibly fast.

2. Tools (The Hands)
These are the actions your agent can take. Read from Notion? That's a tool. Send a Slack message? Tool. Create a calendar event? Tool. Agent Builder connects to external services through MCP (Model Context Protocol) servers like Zapier's, which is OpenAI's standardized way for AI agents to securely interact with external applications and APIs.

3. Workflow (The Process)
This is the visual flowchart you build. It defines how your agent uses its tools. Do you want it to check one source, or multiple? Should it clean up its output before showing the user? Do you need approval gates? You design this in the GUI by connecting nodes.

The beautiful thing is you're never writing code to make these components work together. You're just configuring them through forms and dropdowns.

Step 1: Create Your Knowledge Base (Notion Setup)

First, we need something for our agent to read from. I'm using Notion because it's easy to update and integrates cleanly with Agent Builder through Zapier.

Head to Notion and create a new page. Call it whatever makes sense—I named mine "TrekWise Knowledge Base."

Now structure your content clearly. Use headers, bullet points, and distinct sections. Agent Builder will read this entire page, so organization matters.

Here's the structure I used:

# TrekWise Adventure Travel Knowledge Base

## About TrekWise
We offer eco-conscious adventure travel expeditions to remote wilderness areas.

## Expeditions

### Patagonia Expedition
- Duration: 12 days
- Difficulty: Moderate to challenging
- Group size: 8-12 people
- What's included: All meals, camping gear, expert guides, permits
- Price: $3,200 per person
- Best time to visit: November to March

### Nepal Trekking Experience
[Similar structure]

### Tasmania Wilderness Journey
[Similar structure]

## Frequently Asked Questions

**What's included in the expedition price?**
All our expeditions include meals, camping equipment, expert guides, permits, and group gear. You'll need to bring personal items and clothing.

**Do I need previous hiking experience?**
Our Patagonia and Nepal treks require good fitness and some hiking experience. Tasmania is suitable for beginners with moderate fitness.

[More FAQs...]

Pro tip: Write answers in full sentences as if you're speaking to a customer. This gives your agent better source material to work with than bullet points alone.

Once your page is ready, keep it open—you'll need to connect it to Zapier in a moment.

Step 2: Connect Zapier to Your Apps

Agent Builder can connect to external tools through MCP servers, and Zapier provides one of the most comprehensive MCP servers available. Think of Zapier as the universal translator between your agent and your apps, using OpenAI's MCP architecture to enable secure, standardized communication.

Go to zapier.com → App Connections → Add Connection

Connect Notion: When the permission screen appears, click Select pages (not "allow all") and choose only your TrekWise knowledge base page. This scopes the permission tightly—your agent can only read this one page, nothing else in your Notion workspace.

That's it for connections. Simple, right? Now Zapier knows which accounts your agent will use when it needs to read from Notion.

Step 3: Open Agent Builder and Create Your Agent

This is where the magic happens. Head to platform.openai.com and look for Agent Builder in the sidebar.

If you don't see it, you might need to enable it in your account settings—OpenAI has been rolling this out gradually over the past few months.

Click Create Agent and you'll land on a blank canvas. This is your workspace.

Name Your First Agent: The RAG Agent

Click to add your first node and name it something descriptive. I called mine "RAG Agent" because its job is to retrieve information from our knowledge base (that's the "R" in RAG—Retrieval-Augmented Generation).

Don't worry about what RAG means technically yet—just know this agent's job is to read from Notion and find answers to questions.

Step 4: Connect the Zapier MCP Server (Give Your Agent Tools)

Now we're going to give this agent the ability to actually do something. In Agent Builder, that means connecting tools.

Click on your RAG Agent node → Tools → + Add Tool → MCP Server → Zapier

You'll see a prompt asking for your Zapier API key. Click "Get API key" and it'll redirect you to mcp.zapier.com.

Copy that key and paste it back into Agent Builder. Hit Connect.

Now Agent Builder can talk to Zapier, which means it can talk to any app you connected in Step 2.

Configure the Notion Tool in Zapier

This is the specific capability we're adding: the ability to read your Notion page.

Go back to the Zapier MCP dashboard where you got your API key. This is where you'll configure the Notion integration:

Select Notion → Get Page and Children and configure it:

PageId: Click "Set a specific value" → Select your TrekWise knowledge base page from the dropdown
Leave everything else as default
Hit Save

Important: Find the toggle that says "Require approval for this tool" and turn it OFF. You want your agent to automatically read from Notion when needed, not ask permission every time.

Now go back to Agent Builder and make sure only the notion_get_page_and_children tool is selected for your agent.

What just happened? You gave your agent a superpower: whenever it needs information, it can now pull up your entire Notion page and search through it. No code. Just configuration.

Step 5: Write Your Agent's Instructions (The Critical Part)

This is where you teach your agent how to think. The instructions you write here determine how your agent behaves, how it uses its tools, and how it responds to users.

Click on the Instructions field in your RAG Agent and paste something like this:

You are the TrekWise knowledge assistant.

Your job: Answer customer questions about TrekWise expeditions using information from the TrekWise knowledge base.

How to work:
1. When a user asks a question, use the tool `notion_get_page_and_children` to read the TrekWise knowledge base (page ID already configured)
2. Treat the returned text as your complete source of truth
3. If the information is in that page, summarize it clearly and naturally
4. If the answer is NOT in the page, say politely: "I don't have that information in our guide yet, but I'd be happy to help with something else!"
5. Never mention Notion, tools, or internal processes—speak like a TrekWise team member
6. Keep answers short and confident
7. Use bullet points for lists

Example:
User asks: "Tell me about the Patagonia Expedition"
→ You read the knowledge base, find the Patagonia section, and respond with the key details (duration, difficulty, price, what's included, etc.)

These instructions are doing a lot of heavy lifting:

They tell the agent which tool to use (the Notion reader)
They define how to use it (treat it as source of truth)
They set tone (speak like a team member, not a robot)
They handle edge cases (what to say when you don't know)
They give examples (so the agent understands the pattern)

This is the brain of your operation. The better your instructions, the better your agent performs.

Configure Display Settings

Two quick toggles at the bottom of your agent configuration:

Display response in chat: Turn this OFF
Show search sources: Turn this OFF

These are debugging features. During testing they're useful, but customers don't need to see "Tool called: notion_get_page_and_children" when they ask about pricing. They just want the answer.

Step 6: Add a Display Agent (Polish the Output)

Here's a technique I picked up from building these agents: the raw output from your RAG agent sometimes includes technical debris—tool traces, JSON snippets, metadata tags.

So add a second agent whose only job is to clean that up.

Click + Add Agent in your workflow canvas and name it "Display Agent"

Connect it to your RAG Agent—this agent receives the RAG agent's output and processes it.

In the Display Agent's instructions:

You are the Display Agent. Your job is to take the RAG Agent's output and present it cleanly to the user.

What to do:
1. Receive the previous agent's raw output
2. Remove any internal debug info, tool names, JSON wrappers, or technical metadata
3. Add natural conversational framing like:
   - "Here's what I found about that..."
   - "Based on our TrekWise guide..."
4. If the RAG agent says "not found", convert it to: "I don't have that info in our guide yet. Can I help with something else?"
5. NEVER call any tools yourself—just clean up and return the text
6. Output exactly what you want the customer to see

Your output is what the customer reads. Make it clean, friendly, and natural.

Set this agent as your End Node—the final step before output reaches the user.

Now your workflow is: User question → RAG Agent (reads Notion) → Display Agent (cleans output) → User sees polished answer.

This two-agent pattern is optional but makes a huge difference in output quality. The RAG agent focuses on accuracy, the Display agent focuses on presentation.

Step 7: Test Your Agent in Preview Mode

Before deploying this to your website, let's make sure it actually works.

Click Preview in the top-right corner of Agent Builder.

A chat interface appears. Try some questions:

"Tell me about the Patagonia Expedition"
"What's included in the price?"
"Do I need hiking experience for Nepal?"
"How much does Tasmania cost?"

Watch what happens:

Your agent receives the question
It calls the Notion tool to read your knowledge base
It finds the relevant section
It formats a clean answer
The Display Agent polishes it
You see the final response

If something feels off—maybe the tone is too formal, or it's not finding answers correctly—go back and tweak your instructions. Agent Builder makes iteration fast: edit → save → test → repeat.

This is where you'll spend most of your time: testing edge cases and refining behavior. The good news is you can do this all in the GUI without touching code.

Step 8: Publish Your Workflow

Once you're happy with how your agent responds, it's time to make it real.

Click Publish in the top-right corner.

Give your workflow a memorable name—I called mine "TrekWise Chatbot"—and hit Publish to confirm.

OpenAI will deploy your agent and generate the necessary credentials for embedding it on your website.

Your agent is now live and ready to be added to a web page. This is the moment Agent Builder shines: you just built a working AI system without writing a single line of integration code.

Step 9: Deploy ChatKit to Your Website

Now comes the payoff: putting your agent on your actual website as a chat widget.

OpenAI calls this embedding system ChatKit. It's a pre-built chat interface (that little bubble in the corner of websites) that connects directly to your published agent.

Configure Your Domain

In Agent Builder, click ChatKit → Add domain

Enter your website's domain. In my case, I deployed TrekWise to GitHub Pages, so it's fourixai.github.io. If you have a custom domain, use that.

Hit Generate key and copy the key that appears. It'll look like domain_pk_68ec696807xxxxxxxxxxxxxxxxxxxxxxxxxxx5c73520cd16.

This key is how ChatKit knows your website is authorized to use your agent. Keep it handy.

Add the ChatKit Script to Your HTML

Open your website's main HTML file (usually index.html) and add this single script tag inside the <head> section:

<script
  src="https://cdn.platform.openai.com/deployments/chatkit/chatkit.js"
  async
></script>

That's the core integration - just the script tag. ChatKit is now loaded on your site and will automatically look for your published agent using the domain key you generated.

Save and deploy your site. The ChatKit script will automatically render a chat bubble on your page, or you can customize how and where the chat appears.

If You're Using React or Another Framework

Agent Builder also provides framework-specific packages. For React:

npm install @openai/chatkit-react

Then import and add the component to your page wherever you want it to appear:

import { ChatKit } from '@openai/chatkit-react';

function MyPage() {
  return (
    <div>
      <h1>Welcome to TrekWise</h1>
      <p>Your adventure travel content here...</p>
      <ChatKit
        domainKey="your-domain-key-here"
        workflowId="your-workflow-id-here"
      />
    </div>
  );
}

This gives you complete control over where and how the chat widget appears on your page. Full docs at platform.openai.com/docs/guides/chatkit.

The GUI setup is identical—you're still building your agent in Agent Builder. The only difference is how you embed the chat widget on your page.

Step 10: Handle Authentication (Cloudflare Pages Example)

If you're hosting on a static platform like Cloudflare Pages, GitHub Pages, or Netlify, there's one more piece: session management.

ChatKit needs to create a secure session for each visitor without exposing your OpenAI API key to the public internet. Different platforms handle this differently, but the pattern is the same: a serverless function that acts as a secure middleman.

Here's the Cloudflare Pages version. Create a folder structure: /functions/chatkit/session.ts

Paste this code:

import type { PagesFunction } from "@cloudflare/workers-types";

interface Env {
  OPENAI_API_KEY: string;
  WORKFLOW_ID: string;
}

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Headers": "Content-Type, Authorization",
  "Access-Control-Allow-Methods": "POST, OPTIONS",
};

export const onRequest: PagesFunction<Env> = async ({ request, env }) => {
  const method = request.method.toUpperCase();

  if (method === "OPTIONS") {
    return new Response(null, { status: 204, headers: corsHeaders });
  }

  if (method !== "POST") {
    return new Response("Method Not Allowed", {
      status: 405,
      headers: { ...corsHeaders, Allow: "POST" },
    });
  }

  if (!env.OPENAI_API_KEY || !env.WORKFLOW_ID) {
    return new Response("Server missing OpenAI configuration.", {
      status: 500,
      headers: corsHeaders,
    });
  }

  const openaiRes = await fetch("https://api.openai.com/v1/chatkit/sessions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${env.OPENAI_API_KEY}`,
      "Content-Type": "application/json",
      "OpenAI-Beta": "chatkit_beta=v1",
    },
    body: JSON.stringify({
      workflow: { id: env.WORKFLOW_ID },
      user: crypto.randomUUID(),
    }),
  });

  if (!openaiRes.ok) {
    const errorText = await openaiRes.text();
    return new Response(errorText, {
      status: openaiRes.status,
      headers: corsHeaders,
    });
  }

  const { client_secret } = await openaiRes.json<{ client_secret: string }>();

  return new Response(JSON.stringify({ client_secret }), {
    status: 200,
    headers: {
      ...corsHeaders,
      "Content-Type": "application/json",
      "Cache-Control": "no-store",
    },
  });
};

What this does: It creates a secure session for each website visitor. Think of it as a bouncer who checks credentials server-side and issues temporary passes. Visitors get access to chat with your agent, but they never see your API keys.

Set Environment Variables

Go to Cloudflare Dashboard → Workers & Pages → your project → Settings → Environment Variables

Add two variables:

OPENAI_API_KEY: Your OpenAI API key (mark as Secret/encrypted)
WORKFLOW_ID: Your workflow ID from Agent Builder

Deploy again, and your chat widget will now work properly with authenticated sessions.

The Results: What Actually Works

After going through this process, here's what surprised me:

The knowledge base updates automatically. When I change pricing in Notion, the chatbot instantly has the new information. No redeploying, no retraining—just edit and it's live.

The chat interface is intuitive. The demo shows how people prefer asking questions in natural language rather than hunting through FAQ pages. The chat widget makes finding information frictionless.

It handles unexpected questions gracefully. When someone asks about something not in the knowledge base (like "Do you offer trips to Antarctica?"), the agent politely says it doesn't have that information rather than hallucinating.

The two-agent pattern was worth it. The Display Agent consistently removes technical artifacts and makes responses feel more natural.

What This Means for Businesses

Agent Builder changes the calculation for small businesses:

Before: Custom chatbot = $5,000-20,000 development project + monthly maintenance
After: Working AI agent = 15 minutes setup + OpenAI usage fees (typically pennies per interaction)

More importantly, it puts the power back in the hands of people who actually know the business. You don't need to translate your knowledge base into JSON schemas or API specifications. You just write it like you'd explain it to a new employee, and the agent figures out the rest.

The real breakthrough isn't technical—it's that your subject matter experts can now build AI tools without becoming developers.

Limitations and Considerations

Agent Builder is still in its infancy, and it's important to understand where it shines and where it has limitations:

It's quite basic in functionality. Agent Builder doesn't offer the massive amount of features you'd find in mature automation platforms like n8n or Zapier. Currently missing features include:

Retry mechanisms for failed tool calls
Custom node creation
Advanced error handling
Advance loop constructs
Complex data transformation
Triggers that aren't chat-based

However, Agent Builder is actively evolving and OpenAI is regularly adding new capabilities.

But it's much closer to the LLM. What Agent Builder lacks in features, it makes up for in proximity to GPT. The integration feels more natural and the reasoning capabilities are more powerful because you're working directly with OpenAI's models rather than going through multiple layers of abstraction.

It can be deployed very quickly. While we ended up with a few lines of code including the required backend authentication function, the deployment process is still remarkably fast compared to traditional development approaches.

It's still dependent on your knowledge base quality. Garbage in, garbage out. The agent can only work with what you give it.

Complex reasoning may hit limits. If customers need multi-step comparisons or calculations that aren't explicitly in your documents, the agent might struggle.

You need to monitor conversations. Like any AI system, it can occasionally misinterpret questions or provide incomplete answers.

Usage costs add up. While typically cheap, high-traffic sites should monitor their OpenAI API usage.

The Bigger Picture

Agent Builder represents a fundamental shift in how we think about AI deployment:

From: Building custom integrations and managing infrastructure
To: Configuring workflows through visual interfaces

From: Technical teams implementing AI features
To: Business experts directly creating AI tools

From: Long development cycles and testing phases
To: Rapid prototyping and immediate deployment

This democratization of AI building is happening across the board. Tools like Agent Builder, Zapier, and others are removing the technical barriers that kept AI capabilities locked away in engineering departments.

Try it yourself! Visit the live demo at trekwise-adventure-blueprint.pages.dev to see the TrekWise chatbot in action, or clone the repository from github.com/FourixAI/trekwise-adventure-blueprint to explore the complete implementation.

What to Build Next

Once you have this basic pattern working, you can expand it:

Multi-source knowledge bases: Connect to multiple Notion pages, Google Docs, or databases
Handoff to human agents: Add logic to escalate complex questions to real staff
Proactive engagement: Trigger the chat based on user behavior
Integration with booking systems: Let customers check availability or make reservations
Analytics and feedback: Track what questions people ask most frequently

The visual workflow interface makes it easy to experiment with these capabilities without rewriting code.

Final Thoughts

Agent Builder isn't just another AI tool—it's a glimpse at how AI deployment should work. The fact that I can build a working customer support system in 15 minutes, connect it to my existing knowledge sources, and deploy it with just a few lines of code (including the a small backend authentication function) shows how far we've come.

The low-code approach doesn't just make things faster—it makes them more accessible. Your marketing team can build a product recommendation bot. Your HR department can create an onboarding assistant. Your support team can build a triage system.

And they can do it all without waiting for the development queue.

The most powerful AI tools aren't the ones with the most features—they're the ones that turn expertise into automation. When the people who live and breathe these problems can directly build the solutions, that's when AI stops being impressive and starts being indispensable.

Want to dive deeper into AI automation and low-code development? I share practical experiments, implementation details, and real-world examples over at gaul.dev. Come join the conversation about building the future of AI-powered workflows.

Part 2: The Upgrade That Turns Claude Into a Persistent Workspace Operator

Tim Gaul — Thu, 09 Oct 2025 07:23:47 +0000

"GPTs made AI automation possible. Claude + Zapier MCP made it effortless."

This is Part 2 of my series on building practical AI assistants. If you haven’t built the Part 1 foundation yet, start there: Part 1: The 5-Minute Setup That Turns ChatGPT Into Your Real Assistant. For the broader context, see the series hub: From ChatGPT Prototype to Real AI Assistant: How I Automated My Daily Planning.

This post follows naturally from Part 1: The 5-Minute Setup That Turns ChatGPT Into Your Real Assistant, where we built a custom GPT that could actually write to your calendar. If you haven't read Part 1, the quick version is this: we solved the copy-paste problem by connecting ChatGPT to Zapier so it could create calendar events automatically instead of just suggesting them.

That GPT setup is genuinely useful. It works. Lots of people are using it successfully right now.

But here's what I realized after living with it for a few weeks: custom GPTs are the old way of doing AI automation. They get the job done, but they're not nearly as flexible or powerful as what's possible today.

Think of custom GPTs like the early iPhone—revolutionary for its time, but once you've used an iPhone 15, you notice all the limitations you used to tolerate.

The new way? Claude with Zapier MCP. Same basic idea, but with a fundamental architectural difference that changes everything about how your assistant actually works.

Why GPTs Feel Like the Old Way

After using that ChatGPT scheduling assistant for a few weeks, I started noticing the cracks. Nothing broke exactly—it just felt... constrained.

Every morning I'd open a new chat, enable the Outlook connector, and paste in my task list from wherever I'd scribbled it down. The assistant would check my calendar, build a smart schedule, and create the events. Mission accomplished.

But here's what kept bugging me: my task list lived in Notion with all this beautiful metadata—priorities, time estimates, energy levels, due dates. ChatGPT couldn't see any of that. So I'd manually copy tasks over in a format it could understand, losing all the context in translation.

It was like having an assistant who could only read sticky notes while all my actual work lived in a sophisticated database.

And the connector situation? Every single morning I had to enable Outlook access again. Click, authorize, wait. It's only a few seconds, but when you're doing it daily, those seconds add up to frustration.

The bigger issue wasn't the friction—it was the flexibility. With GPTs, you're locked into OpenAI's integration system. They decide which apps get connectors. They control how those connectors work. Want to connect to Notion? Hope they build it. Want to pull from a custom database? Good luck.

GPTs solved the automation problem beautifully, but they left me wanting more control.

What Changed When I Discovered Claude MCP

I kept hearing about Claude's "MCP" thing—Model Context Protocol. The name sounds intimidating, like something you'd need a computer science degree to understand. But when I finally tried it, I realized it's just a fancier version of what we built in Part 1, except with one crucial difference: persistence.

With ChatGPT's approach, you're granting permissions every time. With Claude MCP, you're setting up permanent abilities your assistant can reuse across every conversation.

Think of it like this: ChatGPT is like having a temp worker show up each day. You have to show them where everything is, give them permissions to use the tools, explain the routine. They do great work! But tomorrow, you start over.

Claude with MCP is like having an actual employee. You give them access once, show them your systems, and they remember. They already know where your tasks live, how your calendar works, and how you like things done.

Here's what my morning looks like now: I open Claude and type "build today's schedule." That's it. No connector-enabling. No task-list-pasting. No permission-granting dance.

Claude already knows how to pull my tasks from Notion, check my Outlook calendar, build a conflict-free schedule, and send me a Slack digest. It just... does it.

That shift from "assistant I have to manage" to "operator I can trust" is what this guide is about.

What You're About to Build

By the end of this, you'll have created something that feels a bit like magic but is actually just good engineering:

A Notion Tasks database that captures everything about your work—not just what needs doing, but how long it takes, how much energy it requires, and when it's due.

A private Zapier MCP server you completely control, with a secret URL you can rotate anytime. Think of this as your assistant's permanent ID badge for accessing your workspace.

That server will expose exactly four abilities: query your Notion tasks, read your Outlook calendar, create calendar events, and send you Slack messages. Nothing more, nothing less.

Claude connected to that server, so those abilities are always available across every chat you ever have. No re-authenticating. No re-explaining. Just permanent, safe access to the tools your assistant needs to actually help.

The beautiful part? You can build all of this without writing a single line of code. Just clear permissions and a simple playbook.

Step 1 — Create Your Notion Task Database (Let AI Do the Work)

Here's where we start getting smarter about how we work. Instead of treating your tasks like a dumb checklist, we're going to build a database that captures the context around each task.

Open Notion, click anywhere, and look for the "Build with AI" button. When the chat pops up, paste this:

Build a Notion database schema for managing tasks.
The database should have columns/properties:

Title (task name)
Due Date (date)
Status (select: To Do / In Progress / Done)
Estimate (mins) (number)
Priority (select: Low / Medium / High)
Energy Tag (select: Creative / Admin / Heavy / Light)
Notion URL (link/URL property)

After creating the database, set up an action to add new task items into this database with those fields.

Watch Notion's AI build your database in real-time. It's oddly satisfying.

Here's why this matters more than you might think: when your assistant can see that "Write Q4 strategy deck" takes 90 minutes, is high priority, and requires creative energy, it doesn't just slot it into the first available hole in your calendar. It can put it in the morning when you're fresh, give it a contiguous block instead of chopping it up, and make sure it happens before the deadline.

Context turns scheduling from Tetris into strategy.

Once Notion finishes building the database, add a couple of sample tasks so you can see how it looks. Make one high-priority creative work, one low-priority admin task. You'll thank yourself later when you're testing.

Step 2 — Connect Your Apps (and Actually Give Permission This Time)

Head to Zapier → App Connections and connect three accounts: Microsoft Outlook, Slack, and Notion.

The Outlook and Slack connections are straightforward—add connection and just sign in and approve. But Notion has a gotcha that trips everyone up the first time.

When you connect Notion, it'll ask what pages Zapier can access. This is where most people click "Allow access to all pages" because they're in a hurry. Don't do that.

Instead, click Select pages and choose only your Tasks database. Nothing else.

Why this matters: You're building an automated system that will touch your workspace every day. Being specific about permissions isn't paranoia—it's good hygiene. If something weird happens (spoiler: nothing will), your assistant can only mess with your task list, not your entire Notion workspace.

Think of it like giving someone the key to your garage, not your whole house.

Step 3 — Create Your Zapier MCP Server (Your Assistant's Permanent Badge)

Alright, this is where things get interesting. We're about to create what Zapier calls an "MCP server," which sounds incredibly technical but is actually just a secure control room for your assistant.

Here's what MCP really means in plain English: it's a system that decides what your AI can and can't do. You tell it "Claude can read my Notion database" or "Claude can send me a Slack message," and Zapier enforces those rules. Nothing more, nothing less.

Every MCP server lives under your Zapier account, which means you own the keys. You decide which actions are visible. You can revoke or rotate access any time with a single click.

When we "configure tools" in a minute, we're literally choosing which switches Claude can flip. It's like being a building manager who decides which rooms each employee can unlock.

Head over to mcp.zapier.com and click + New MCP Server.

Pick Claude as your client and name your server something memorable. I went with "WorkspaceOperator" because it sounds way cooler than "my-schedule-thing."

Hit Create and you'll land on a screen with three tabs: Configure, Connect, and History.

Click into the Connect tab and you'll see your Integration URL. This is your secret key—treat it like a password. Anyone with this URL could theoretically use your assistant's abilities, so don't go pasting it in public Slack channels.

The beautiful thing? See that Rotate secret button right below it? If you ever want to revoke access completely, click that and the old URL stops working instantly. Your assistant gets locked out until you give it the new one.

This is the safety net. You're in control. Always.

Step 4 — Configure Your Tools (This Is Where Everything Clicks)

This is the heart of the whole setup. Everything you've done so far—building the Notion database, connecting your apps, creating the MCP server—was prep work. This step is where you actually decide what your assistant can do.

Think of your Zapier MCP server as an empty control console right now. No buttons, no permissions, nothing Claude can actually touch. We're about to add exactly four abilities, and only these four. If it's not in this list, Claude can't do it.

Click over to the Configure Tools tab. This is where you'll connect your existing app accounts (Notion, Outlook, Slack) and choose the specific actions Claude will be able to use.

Add Your Notion Tools (The Brain)

We'll start by letting Claude read from and optionally write to your Tasks database.

Click Add Tool → Notion → Query Database (Advanced) and then expand Notion, then click the three dots next to **Query Database (Advanced)* and configure like this:

Account: your Notion connection (this is pre-filled)
Database: Set a specific value for this field and select the Tasks database you created earlier

Leave everything else as default.

Add Your Outlook Tools (The Schedule)

Microsoft Outlook → Get Calendar Events in Date Range and configure:

Account: your Outlook account (this is pre-filled)
Calendar: Set a specific value for this field and select your main working calendar

Leave everything else as default.

Microsoft Outlook → Create Event and configure:

Account: your Outlook account (this is pre-filled)
Calendar: Set a specific value for this field and select your main working calendar
Show me as: free (this is optional)

Leave everything else as default.

Add Your Slack Tool (The Messenger)

Slack → Send Direct Message and configure

Account: Slack
To Username: Set a specific value for this field and select your name

Leave everything else as default.

Once added, enable all four tools (1 Notion, 2 Outlook, 1 Slack).

Step 5 — Connect Claude to Your MCP Server (The Handshake)

In Claude (web or desktop): click your user icon → Settings → Connectors → Browse connectors

Select Zapier, then connect. Paste in the URL from your Zapier MCP (under the Connect tab).

Hit Continue. You may need to grant access to Claude, and click Allow if you haven't previously done so.

Open a new chat and under Search and Tools you should see your four tools listed. If not, double-check each tool is enabled in Zapier.

This is the handshake—persistent capabilities instead of one-off permissions.

Your browser doesn’t support inline video. Download the walkthrough MP4. Short walkthrough: connecting Claude to the Zapier MCP server and verifying the tools appear in Claude’s interface.

Step 6 — Create Your Project (Where Claude Remembers Everything)

Projects are Claude's persistent workspaces. Instead of re-explaining context every session, you anchor instructions, tools, and memory in one place.

In Claude: Projects → + New project

Name: Daily Digest

Description: Uses Zapier MCP to populate daily calendar with unfinished tasks

Step 7 — Give Your Project Instructions (The Brain of the Operation)

Open your new project. In the Instructions panel, paste:

You are a "Daily Scheduler Agent" using a Zapier MCP Server.
You have access to these tools:
- microsoft_outlook_get_calendar_events_in_date_range
- microsoft_outlook_create_event
- notion_query_database_advanced
- slack_send_direct_message

Goal: Build and send a daily schedule based on Notion tasks and Outlook calendar, then DM me the summary in Slack.

Workflow:
1) Fetch today's Outlook events (treat as busy). Timezone = UTC+10:00 (Brisbane).
2) Query Notion "Tasks" where Status != "Done".
   Return: title, due_date, estimate_mins, priority, energy_tag, notion_url.
   Sort: Priority High→Medium→Low, then Due Date ascending.
3) Working window: 09:00–16:30 (UTC+10).
4) Fit tasks into free slots: Creative/Heavy first, then Admin/Light. Add 5–15 min buffers. If no fit, mark Deferred.
5) Ask once for approval. On "yes", create Outlook events (Show me as = Free) and send a Slack DM with:

🗓 Meetings
- [start–end] — title

📋 Scheduled
- [start–end] — Task (energy)

📌 Deferred
- Task name

Save.

Step 8 — Take It for a Test Drive (The Moment of Truth)

In the project chat:

Build today's daily digest.

Constraints:
- Timezone: Brisbane (UTC+10)
- Working window: 09:00–16:30

Claude will:

Read Outlook events
Query Notion tasks (excluding Done)
Sort + prioritize
Allocate blocks with buffers
Ask for approval
On confirmation: create events + send Slack digest

Approve it.

What Just Happened Here

You didn't build another one-off automation. You gave your AI reusable powers—safely scoped by Zapier, visible in one place, and available every single time you open a chat.

That's the difference between "assistant that suggests" and operator that executes.

Old way: Open chat → Enable connectors → Paste tasks → Hope it works → Repeat tomorrow

New way: Open project → Type "build today's schedule" → Approve → Done

Where This Goes Next

I've been using this setup for weeks now, and the trust factor is what surprised me most. When your assistant knows where your work lives and how you like things done, you stop second-guessing it.

I don't stare at the proposed schedule anymore wondering if it missed something. I just say yes and get to work.

That shift from "tool I have to manage" to "teammate I can trust" is what makes all of this worth it.

Further reading:

If this helped you build something useful, I'd love to hear about it. What creative uses are you finding for persistent AI assistants? What other tools would make this even better?

Part 1: The 5-Minute Setup That Turns ChatGPT Into Your Real Assistant

Tim Gaul — Wed, 10 Sep 2025 02:46:30 +0000

"ChatGPT could plan my day — but it couldn't do anything about it. Now it can."
This is Part 1 of my continuing series on building practical AI assistants. You can find the complete technical guide and additional resources at From ChatGPT Prototype to Real AI Assistant: How I Automated My Daily Planning.

I've been there. You know that moment when you paste your entire to-do list into ChatGPT, ask it to organize your day, and it spits out this beautiful, perfectly timed schedule? Then you stare at it for a minute, sigh, and manually type each item into your calendar one by one.

What if I told you that frustrating copy-paste dance could be over in the next five minutes?

I'm about to show you how I turned ChatGPT from a planning suggestion box into an actual assistant that writes directly to my Outlook calendar. No coding required, no technical wizardry, just a simple setup that works every single time.

What You're About to Build

By the time you finish reading this, you'll have your own AI assistant that:

Reads your existing calendar to avoid double-booking you
Takes a messy list of tasks and creates a smart daily schedule
Actually puts those events in your Outlook calendar (not just suggests them)

The whole thing takes about five minutes to set up, and once it's done, planning your day becomes as simple as sending a message. No code, no webhooks, no ICS files. Just ask → schedule → done.

Step 1: Give Zapier Access to Your Calendar

Think of this first step as introducing your assistant to your calendar. We're going to use Zapier as the middleman that lets ChatGPT actually talk to Outlook.

Head over to Zapier and look for "App Connections" in your dashboard. When you click "Add Connection" and search for Microsoft Outlook, it'll ask you to sign in with your Microsoft account. This part always feels a little scary (you're giving access to your calendar, after all), but Zapier's been around forever and they're legitimate.

The permissions it asks for are just so your assistant can peek at your existing appointments and add new ones when you tell it to. Think of it like giving a friend a key to your house so they can water your plants while you're away.

Zapier App Connections screen establishing secure Microsoft Outlook calendar integration for the assistant

Step 2: Create Your Personal Planning Assistant

Now for the fun part. Go to ChatGPT, find "GPTs" in the sidebar, and click "Create." This is where you get to build your own custom assistant from scratch.

Here's what I've found works best:

Name: I went with "Daily Task Scheduler" but call it whatever makes you smile. "Task Ninja" works too.

Description: Keep it simple: "Builds a conflict-aware daily task schedule from your Outlook calendar and updates the calendar with daily tasks."

Instructions: This is where you teach your assistant how you like to work. I use: "You MUST read all of TODAY's events from Outlook Calendar before suggesting anything. Never ask for calendar permissions. Only ask for confirmation once before scheduling."

Here's the thing about instructions — you can get as specific as you want. Maybe you're one of those people who needs 15-minute buffers between meetings to decompress, or you prefer batching all your creative work in the morning. Add that stuff here. Your assistant will remember it forever.

Conversation Starters: Add a few examples of how you typically dump your tasks. I like:

"Plan my day from 9am to 5pm with these tasks..."
"[deep] = prefer contiguous blocks; [flex] = can move around"

The conversation starters aren't just for show — they actually train your assistant on how you communicate.

Custom GPT builder showing name, description, instructions and conversation starters for the scheduling assistant

Step 3: Let ChatGPT Talk to Zapier

Don't worry — this sounds more technical than it actually is. Think of this step like introducing two friends so they can work together.

Still in your GPT builder, scroll down to "Actions" and click "Create new action." All we're doing here is giving ChatGPT a way to communicate with the Zapier account you just set up.

Choose "Import from URL" and paste this link (I know it looks scary, but it's just Zapier's way of saying "here's how ChatGPT can talk to me"):
https://actions.zapier.com/gpt/api/v1/dynamic/openapi.json?tools=meta

Hit Import. When you see "Available actions" appear, click "Test" next to "list_available_actions."

Now here comes the part that looks intimidating but is totally safe. In the chat window, you'll see a message saying "gpt wants to access your Zapier Account" with a popup asking for permissions.

Don't worry — this is completely normal and safe. This is just ChatGPT asking "Hey, can I talk to your Zapier account so I can help you automate things?" It's exactly like when you let Spotify connect to Facebook or let Google Calendar sync with your phone.

Here's what will happen step by step:

First popup: ChatGPT will show "gpt wants to talk to actions.zapier.com" — click "Always Allow." This just means "yes, my assistant can communicate with Zapier whenever I ask it to."
Zapier login: You'll be redirected to Zapier's website to confirm you're really you. Just log in with the same Zapier account you set up in Step 1.
Permission screen: Zapier will show you exactly what your assistant is asking for:
- Access your Zapier account (so it can see what apps you've connected)
- See your enabled actions (so it knows what it can help you with)
- Run actions and see results (so it can actually do the work)

Click "Allow" — you're not giving ChatGPT the keys to your entire digital life, just permission to use the specific automations you've set up in Zapier.

Think of it like giving a trusted friend permission to use your Netflix account. They can watch shows, but they can't change your password or see your credit card.

Permission dialog requesting limited access so the GPT can run only the Outlook actions you enable via Zapier

You should be returned to the GPT configuration screen and if you see "No available actions yet," don't panic. That's totally normal — it's like having a phone number but no one to call yet. We'll fix that in the next step by actually giving your assistant some useful abilities.

Step 4: Tell Your Assistant What It Can Do

This is the part where we actually give your assistant some useful abilities. We're going to create two simple "skills" — one for reading your calendar, one for adding things to it.

Go to actions.zapier.com/gpt/start (that's Zapier's setup page) and we'll walk through this together.

First skill: Let your assistant peek at your calendar
Click "Add Action" first, then look for "Microsoft Outlook: Get Calendar Events in Date Range" and click it. This just means "let my assistant see what's already scheduled today so it doesn't double-book me."

Select your Outlook account from the dropdown, click "Show all options" to see all your calendars, then choose whichever calendar you actually use for your daily planning.

For everything else, just leave it as "Let AI guess." Zapier is pretty smart about figuring out the details.

Zapier action configuration granting read access to today's Outlook events (conflict awareness)

Second skill: Let your assistant add events to your calendar
Now find "Microsoft Outlook: Create Event" and click that one. Same deal — pick your account and calendar.

One small tip: if you see a "Show me as" option, set it to "Free." This way, when your assistant schedules "Write blog post" from 2-3pm, it won't look like you're in a meeting to anyone trying to schedule time with you.

Hit "Enable Action" for both of these. (I always forget this step and then wonder why nothing works.)

The whole thing should feel like you're just telling Zapier: "Hey, when my assistant asks, it's okay to check my calendar and add things to it."

Step 5: Test Everything

Back in your GPT builder, find Actions and click that little gear icon next to actions.zapier.com. Hit Test again on "list_available_actions."

If you see both of your Outlook actions listed, you're golden. If not, go back to Zapier and double-check that you actually enabled both actions. We've all been there.

Confirmed enabled Outlook actions (Get Events and Create Event) now available to the GPT

Step 6: Launch Your Assistant

Hit "Create" in the top-right corner. Congratulations — you've just built something that would have seemed like science fiction five years ago.

This is the moment your assistant goes from prototype to actually useful. It can now read your calendar, understand what you're trying to accomplish, and make it happen automatically.

Step 7: Take It for a Spin

Time to see if this thing actually works. Click "View GPT" and try this prompt (feel free to swap in your own tasks):

START_TIME=9am END_TIME=4:30pm

Task A (personal, dur: 10m)
Task B (personal, dur: 10m)
Create a video demonstrating vibecoding for non-coders using AI tools (dur: ~2h) [deep]
Produce a video intro for reuse in future recordings (dur: ~1h)
Draft and rehearse script for this week's presentation (dur: ~1h) [flex]
Research options for a company video platform (dur: ~30m) [flex]
Personal commitment (2:40pm – 3:20pm)

Here's what happens next (and don't panic when you see permission requests):

Your assistant checks your calendar for today's meetings
It identifies the BUSY slots where you're already booked
It builds a conflict-free schedule around your existing commitments
It asks: "Do you approve this schedule?"
When you say yes, it creates all the events in your Outlook calendar

You'll see permission requests twice — once when it reads your calendar, once when it writes to it. That's normal. That's just your assistant asking "hey, can I check your calendar?" and then "hey, can I add these events?"

Assistant proposing a conflict-free schedule and requesting approval before creating events

Within seconds, you'll see your perfectly organized schedule appear in your actual Outlook calendar. No file downloads, no manual imports, no copy-paste marathon — just a clean, conflict-free day that actually makes sense.

Resulting Outlook calendar populated automatically with the approved scheduled task blocks

What Just Happened Here?

You've just eliminated the most annoying part of planning your day. No more copying and pasting. No more switching between ChatGPT and your calendar app. No more accidentally double-booking yourself because you misread a time.

The old way: Ask ChatGPT for help → Get suggestions → Open calendar → Create event → Copy details → Set time → Repeat six times → Realize you scheduled two things at once

The new way: Send message → Say yes → Done

The best part? Your assistant learns how you work. Tell it once that you prefer morning blocks for creative work, and it'll remember that forever.

What's Next?

Part 2: How Claude MCP takes this concept even further, giving AI persistent access to your entire digital workspace for power users. We'll look at what changes when your assistant can reuse tools and context across sessions—no hype, just practical extensions of what you built here.

But for now, enjoy having an AI assistant that doesn't just give advice — it actually gets stuff done.

Try building your own version and let me know how it goes. I'm genuinely curious what creative uses you'll find for this.

Curious to dive deeper into open-weight AI and its role in shaping business strategy? Check out my blog where you’ll find this article and more explorations on the subject.

Want to keep the conversation going? Connect with me on LinkedIn — I’d love to hear your perspectives on GPT-OSS and where you see open AI heading next.

From ChatGPT Prototype to Real AI Assistant: How I Automated My Daily Planning

Tim Gaul — Sun, 07 Sep 2025 23:55:03 +0000

ChatGPT helped me design my ideal day, but every morning I found myself retyping tasks, toggling connectors, downloading calendar files, and importing them into Outlook. It was clever, but not seamless. Here's how I took that AI experiment and made it actually save me time.

How It Started: The 8-Step Morning Dance

Picture this: It's 8:47 AM, I'm running late, and I'm staring at a messy to-do list wondering how I'll fit everything in. So I fire up ChatGPT to help me plan my day.

The ritual began:

Open a fresh ChatGPT chat (because yesterday's context is gone)
Scroll through weeks of chat history trying to find that one conversation where my planning prompt actually worked perfectly
Copy-paste that entire prompt, then amend it with today's specific tasks
Enable the Outlook connector (again)

ChatGPT's connector interface showing available integrations including Canva, Notion, Outlook Calendar, Outlook Email, Dropbox, and GitHub - each requiring manual setup and re-enabling

Cross my fingers that ChatGPT interprets everything the same way as yesterday
Wait while ChatGPT thoughtfully arranges my chaos into a neat schedule
Download the mysteriously-named "calendar_events_2024.ics" file
Navigate to Outlook, find the import button, and pray it doesn't duplicate last week's events

The result? A beautiful calendar that perfectly balanced my priorities, accounted for travel time, and even built in coffee breaks.

The problem? This "automation" was taking me 10 minutes of manual labor every single morning.

ChatGPT showed me what was possible but not what was practical. I had built the world's most sophisticated reminder to do things manually.

What This Revealed About AI Today

This is where most AI stories stop—at the cool demo. But I kept using this workflow for weeks, and a pattern emerged that reveals something important about how we think about AI:

LLMs are incredible at prototyping. I had a working "assistant" in an hour, without writing a line of code. ChatGPT could analyze my competing priorities like a seasoned consultant and generate perfectly formatted calendar files. You can have a "working" solution in minutes.

But they're not autonomous or persistent. ChatGPT couldn't remember that I prefer 45-minute meeting blocks, that I'm useless before 10 AM, or even my basic planning preferences from yesterday. Every single morning, I had to dig through chat history to find my working prompt, then manually append today's new tasks to it. Sometimes I'd grab the wrong version and wonder why my calendar looked off. It would occasionally forget formatting mid-conversation, requiring edits before Outlook accepted the ICS file.

The "magic" wears off quickly when you realize you're doing archaeological work in your own chat history, then manually splicing together prompts and task lists every morning.

This revealed something important: LLMs are extraordinary reasoning engines, but they're not automation platforms. When ChatGPT "integrates" with Outlook, you're doing the integration. When it "automates" your workflow, you're running the automation.

The Missing Piece: Zapier as the Bridge

Instead of abandoning ship, I had a different thought: What if I kept ChatGPT for what it's brilliant at—the thinking—and found something else to handle the doing?

Enter Zapier—the unsexy hero of this story. While everyone was talking about AI agents and autonomous systems, I built something simpler using a no-code automation platform that talks to Outlook, Slack, Google Docs, and thousands of other apps.

Now my morning looks like this:

I tell my custom GPT my tasks for the day
ChatGPT plans them out with intelligent reasoning about priorities and timing
Zapier instantly creates and updates events in my Outlook calendar

No files. No uploads. No manual integrations. No 10-minute morning ritual.

Simple automation flow: User input flows through ChatGPT's reasoning to Zapier's execution, ending up in Outlook Calendar

This setup required no programming, just some structured thinking:

ChatGPT still does what it's best at: reasoning about time, priorities, and buffers
Zapier handles what software is best at: acting on decisions automatically

Just: thought → action → done.

The actual ChatGPT-Zapier integration showing saved GPT actions: ChatGPT conversation capabilities combined with Microsoft Outlook calendar events (both reading and creating), all connected through Zapier's automation platform

Why This Simple Change Was Revolutionary

Friction vanished overnight. I went from dreading daily planning to actually looking forward to it. When something takes 30 seconds instead of 10 minutes, you use it differently.

My AI assistant got persistent memory. The custom GPT now stores that elaborate prompt I'd spent hours perfecting—all my scheduling preferences, time blocks, buffer requirements, and output formatting rules. No more hunting through chat history or re-pasting instructions every morning. The planning logic that used to live in my head (and various scattered chat conversations) now lives in a reusable brain.

It became scalable. This same setup could plan someone else's week, run team standups, or automate marketing tasks. The pattern works anywhere you need AI reasoning plus reliable execution.

But here's what surprised me most: I started trusting my calendar again. When something appears there automatically, based on intelligent reasoning about my actual priorities, I follow it. No more 3 PM existential crises about what I should be working on.

This experiment showed me how LLMs plus automation platforms are the sweet spot:

ChatGPT made it real quickly, proving the concept
Zapier made it usable, eliminating repetitive tasks

Lessons Learned

ChatGPT is the best prototyping tool you've ever seen. It will happily write an ICS file, an API call, or a script to organize your day. You can have a "working" solution in minutes.
But it's not an automation engine. It won't wake up on a schedule, remember your settings, or talk to multiple services seamlessly. The magic happens in the connections, not the AI itself.
Automation platforms like Zapier close the gap. They're not as flashy as AI, but they make AI actually helpful by handling the persistent, boring execution work.

The bigger insight: We're in the awkward teenage years of AI. The reasoning is incredible, but the integration layer is still clunky. Most people experience AI as a series of impressive demos followed by the question: "Okay, now what?"

The answer isn't better AI—it's better connections.

Where This Goes Next

I plan to share two guides:

Part 1: The exact 5-minute setup for replicating this ChatGPT plus Zapier workflow (no code required, no jargon)

Part 2: How Claude MCP takes this concept even further, giving AI persistent access to your entire digital workspace for power users

But this article is about the mindset shift that makes it all work:

Stop asking AI to replace your tools. Start asking it to connect them.

AI isn't magic; it's leverage. The future isn't AI doing everything—it's AI making everything you already do dramatically easier.

AI didn't replace me; it removed friction. My daily planning workflow went from 10 minutes of copy-paste busywork to a single sentence in ChatGPT—and that's the difference between a cool demo and a life-changing tool.

Curious to dive deeper into open-weight AI and its role in shaping business strategy? Check out my blog where you’ll find this article and more explorations on the subject.

Want to keep the conversation going? Connect with me on LinkedIn — I’d love to hear your perspectives on GPT-OSS and where you see open AI heading next.

The Rise of Open AI Models: Privacy, Control, and a New Era

Tim Gaul — Thu, 21 Aug 2025 03:09:24 +0000

🚀 Introduction: OpenAI’s Power Move

OpenAI has recently released something that feels like a plot twist: GPT-OSS, their first open-weight model in years. Unlike previous research releases, this one is practical, licensed under Apache 2.0, and strong enough to stand next to GPT-4-mini. It’s a clear move toward the open AI movement—and one that signals a dramatic shift in direction.

What makes it exciting isn’t just the tech, but the symbolism. For years, OpenAI was the poster child for closed (ironically!), centralized AI systems. Now they’re releasing powerful, commercially usable models that anyone can run on their own infrastructure—locally, on their cloud of choice, or in tightly regulated environments. This is no longer about experiments—it’s about freedom, and the market is taking notice.

They’re not alone. Meta’s LLaMA family ignited this trend. Qwen from Alibaba and Grok from xAI pushed boundaries. And a rising tide of open-weight, community-backed models is redefining what it means to build and deploy large language models. Whether you’re a startup, a hobbyist, or an enterprise compliance officer, there’s now a real choice. You don’t have to send your prompts to a black box anymore.

The open model movement is here. And it’s not going away.

🔐 Why This Matters: Privacy, Security, and Control

One of the biggest drivers of the open-source model movement is privacy and data security. When you use a closed AI service—an API or SaaS platform—your data is routed through third-party infrastructure. For sensitive domains like healthcare, finance, law, or defense, this is often a dealbreaker. Questions around where your data is stored, how long it's retained, and whether it's used for training are often unclear—or worse, vary depending on your pricing tier or some opt-out setting buried in a legal doc.

Open-source models give you control, clarity, and compliance.

When you self-host, no sensitive data leaves your infrastructure. You know where it lives, how long it’s retained, and exactly who can access it. That’s not just about technical sovereignty—it’s about legal and ethical responsibility. For industries under GDPR, HIPAA, or financial data compliance, these aren't nice-to-haves; they’re must-haves.

Security is another part of this picture. With open models, you’re not relying on a third party’s security practices—you can apply your own, tailored to your threat model. You can choose what gets logged, audited, encrypted, or isolated. And you’re not at the mercy of another company’s roadmap.

Transparency matters too. Most open-weight models come with full architectural disclosure, and some even detail training sources. That level of visibility lets your teams understand, audit, and vet the models they're using—crucial for AI safety, fairness, and trust.

Then there’s customization. You can adapt the model to your workflows, your tone, your data. Fine-tune it on your internal documentation, product manuals, legal clauses—whatever matters most. That’s often more valuable than raw benchmark performance. You also gain the ability to compress models, reduce inference costs, or embed them directly into your pipelines—not possible with closed APIs.

Performance and uptime improve too. Local or private-cloud inference means no network latency, no rate limits, and no surprise downtime. And if your internet drops, your AI still works.

Finally, OSS fosters innovation. A shared model base allows communities to debug, extend, adapt, and improve on one another’s work. In some cases, the OSS model ecosystem advances faster than closed labs—driven by hundreds of contributors and power users, not one roadmap. That’s a win for transparency, accessibility, and global progress.

In short, OSS models offer something you can’t buy with any proprietary subscription: certainty, flexibility, a seat at the table—and zero licensing or token fees. The only cost is infrastructure, making it especially compelling at scale or for sensitive environments.

💡 Spotlight: GPT-OSS — OpenAI’s Best Open Move Yet

Here’s what you need to know about GPT-OSS:

It’s Open-Weight, Not Open-Source: You don’t get the training data, but you do get the full model weights, architecture, and tokenizer. Crucially, it’s licensed under Apache 2.0—truly open, unlike LLaMA’s more restrictive license.
Two Models: A 120B model that rivals GPT-4-mini, and a 20B model that’s roughly in GPT-3.5 territory. Both use Mixture-of-Experts (MoE), so they’re far more efficient than you'd expect—using just 5B or 3.6B active parameters per generation.
Performance Anchored by Benchmarks: On reasoning benchmarks like MMLU and GSM8K, GPT-OSS-120B scores within ~2–3 points of GPT-4-mini, while the 20B variant is on par with GPT-3.5 (o3-mini). This isn’t lab hype—these are independent leaderboard results.
Versatile Performance: Both models excel at a wide range of tasks—coding, math, reasoning, and tool use—thanks to architectural efficiencies and strong pretraining. They're not just for chatbots; they're capable assistants across many domains.
Runs Almost Anywhere: The 20B model can run on a decent consumer GPU (~16GB). The 120B model needs serious hardware (~80GB GPU), but it’s still manageable without massive clusters. That means on-premises deployments for enterprises, and tinkering on personal machines for hobbyists.
Fine-tuning is Possible: With access to the model weights and tokenizer, organizations can fine-tune GPT-OSS on internal datasets—adding domain expertise, company-specific language, or private knowledge without waiting on a vendor.
Not Tied to Microsoft: While OpenAI still uses Azure for training, inference is totally open. You can deploy it on AWS, GCP, your own bare-metal cluster, or even run it offline.
Built for Accessibility: Because of its MoE architecture and efficient design, inference cost is 5–10% of a full dense GPT-4 class model. You get powerful reasoning with a much lighter runtime footprint—and no ongoing per-token fees.

💡 Cost Advantage at a Glance: With GPT-OSS, you pay no licensing fees or per-token charges—just infrastructure. Compare that to enterprise APIs where costs scale directly with usage.

This release isn't charity. It's a signal: OpenAI understands that developers, enterprises, and even competitors are demanding real control over their AI—and they're finally offering a path to run AI on your own terms.

🌍 The Expanding Ecosystem of Open Models

OpenAI might be making headlines, but they’re joining a wave:

Meta’s LLaMA 2 helped kickstart the open-weight renaissance. Its performance and scaled release showed what was possible—despite licensing limitations.
Qwen-3 (Alibaba) pushed boundaries with a massive 235B model, topping open benchmarks in reasoning and multilingual understanding.
DeepSeek focused on enterprise-ready reasoning performance, with a clean license and growing adoption.
Grok (xAI) stunned many by releasing a 314B MoE model under Apache 2.0. It’s unclear how widely used it is yet, but the licensing alone is a bold move.
Mistral, Falcon, and OpenHermes represent a deep bench of community and startup-led models pushing the boundaries of lightweight, performant AI.

Together, they create an open-source AI ecosystem that’s mature, fast-moving, and competitive. No longer just “good enough,” many of these models are edging toward parity with their closed counterparts—and in specific use-cases, they’re already better.

⚖️ Real Trade-offs to Consider

Open models aren’t for everyone—yet. Here are the big trade-offs:

You need hardware. Even with MoE efficiency, running big models still requires modern GPUs. The 20B tier is accessible; the 120B model, less so.
You need skills. Setting up a safe, efficient LLM stack is no small task. Fine-tuning, inference optimization, safety filters—all require MLOps talent.
You own the output—and the risks. Want moderation? Logging? Uptime SLAs? That’s your responsibility now. Implementing custom moderation and auditing pipelines is essential for responsible deployment.
They’re catching up—but not there yet. GPT-4 and Claude Opus still outperform open models on long-context and nuanced reasoning. That gap is shrinking monthly, but it’s still there.

For many use-cases—especially ones involving sensitive data or domain-specific workflows—these trade-offs are not dealbreakers. They’re a small price for full control.

🔚 Wrapping Up: The Future Is Open (Again)

The future of AI is changing. Fast. What was once locked behind APIs, restricted licenses, and closed infrastructure is now something you can download, run, and improve yourself.

GPT-OSS isn’t just a strong model—it’s a statement. It tells us that even the most successful AI companies understand the need for openness, flexibility, and developer freedom. And it proves that open-weight models are no longer second-class citizens. They're fast, smart, and increasingly production-ready.

Whether you’re a startup founder looking for cost savings, a developer wanting more control, or an enterprise leader navigating compliance and data risk, the open model ecosystem is finally robust enough to support your needs.

We’re entering a world where you don’t just use AI—you shape it. Where privacy isn’t a premium feature. Where control is the default, not the exception. And where innovation doesn’t need permission.

This isn’t just a shift in tooling. It’s a shift in power.

Curious to dive deeper into open-weight AI and its role in shaping business strategy? Check out my blog where you’ll find this article and more explorations on the subject.

Want to keep the conversation going? Connect with me on LinkedIn — I’d love to hear your perspectives on GPT-OSS and where you see open AI heading next.