LIVE WORKSHOP · 10 MINUTES

Build a Sequential
AI Agent Pipeline

Use Claude Code to query the cal.com open source repository, analyze it with a chained AI pipeline, and generate a live competitive intelligence dashboard — automatically.

🔗 AI Agent Type 3 — Sequential Agents  ·  Chained Pipeline · Each Stage Specialised  Learn more →
3Stages
10Minutes
1Dashboard
∞Repos
Stage 1 — Fetch Agent
GitHub API · Raw Data
→
Stage 2 — Analysis Agent
Pattern Detection · Insights
→
Stage 3 — Report Agent
HTML Dashboard · Charts
Progress
0%
Welcome ⏱ Read before starting

Sequential AI Agent:
GitHub Intelligence Pipeline

You'll build a Type 3 agent that chains three specialised Claude stages together — each one passing its output to the next — to produce a competitive intelligence dashboard about cal.com, the open-source scheduling platform.

🔗 What is an AI Agent Type 3 — Sequential?

A chained pipeline where each stage is a specialised AI call. Stage 1's output becomes Stage 2's input. Stage 2's output feeds Stage 3. No stage knows about the others — they're just experts at one thing. This is the foundation of almost every real-world AI workflow. See all 7 Agent Types →

Your 3-stage pipeline architecture
Stage 1 · Fetch
GitHub API Agent
Queries cal.com repo via GitHub API: issues, PRs, contributors, releases, stars
→ raw JSON data
→
Stage 2 · Analyse
Intelligence Agent
Finds patterns, categorises features, flags competitive signals and roadmap trends
→ structured insights
→
Stage 3 · Report
Dashboard Agent
Renders a complete HTML dashboard with tables, metrics, and visual highlights
→ dashboard.html
Why cal.com?
🎯
Directly relevantCal.com is the open-source Calendly alternative — your closest open-source competitor in the scheduling space
📊
Rich data55,000+ stars, thousands of issues, active PRs, and a detailed roadmap all accessible via public API
💡
Real intelIssue trends reveal what scheduling users actually complain about — direct signal for your product roadmap
🔄
Reusable patternSwap cal.com for any repo — this pipeline works for competitor tracking, dependency audits, or OSS monitoring
What you need
  • ✓
    Claude Code installed — run npm install -g @anthropic-ai/claude-code if not yet installed
  • A terminal open and ready — Claude Code runs from the command line
  • (Optional) A GitHub Personal Access Token for higher API rate limits — not required for this workshop
⚡

Hit "Begin Sprint" to start the 10-minute countdown. You'll run three sequential Claude Code prompts, each building on the last. The final output is a complete HTML dashboard saved to your local machine.

Step 1 of 5 🔵 Stage 1 — Fetch Agent ⏱ 3 minutes

Stage 1: Fetch Agent
Query GitHub API

The first agent in your pipeline has one job: hit the GitHub API for cal.com and pull structured raw data. It saves everything to a JSON file that Stage 2 will consume.

🔵 What this agent does

Stage 1 is purely a data fetcher. It calls four GitHub API endpoints, normalises the results, and writes a single calcom_data.json file. No analysis, no interpretation — just clean, structured data for Stage 2 to work with.

How to run Stage 1
  • 1
    Open your terminal and navigate to a working directory: cd ~/Desktop && mkdir calcom-intel && cd calcom-intel
  • 2
    Launch Claude Code in this directory: claude
  • 3
    Copy the Stage 1 prompt below and paste it into the Claude Code prompt. Hit Enter and let it run.
  • 4
    Wait for Claude Code to finish — it will confirm that calcom_data.json has been created. Don't move on until you see this confirmation.
Stage 1 — Fetch Agent Prompt
STAGE_1_FETCH.txt — Paste into Claude Code terminal
You are a data fetching agent. Your only job is to query the GitHub API and save structured data. Task: Fetch the following data from the public GitHub API for the repository "calcom/cal.com": 1. Repository metadata: stars, forks, watchers, open issues count, description, created_at, updated_at, language, license 2. Recent issues (last 50 open issues): title, labels, created_at, comments count, state, author login 3. Recent pull requests (last 30 open PRs): title, labels, created_at, author login, changed_files, additions, deletions 4. Top 15 contributors: login, contributions count, avatar_url 5. Latest 10 releases: tag_name, name, published_at, body (truncated to 200 chars) Use the GitHub REST API (https://api.github.com). No authentication token required for public repos at low volume. Save all fetched data into a single file called calcom_data.json with clear top-level keys: "repo", "issues", "pull_requests", "contributors", "releases". After saving, print: "✅ Stage 1 Complete — calcom_data.json saved with [N] issues, [N] PRs, [N] contributors"
// Claude Code will write and execute the fetch script automatically. Estimated time: 30–60 seconds.
💡

What Claude Code does behind the scenes: It writes a Node.js or Python script, executes it in your terminal, handles pagination, and saves the JSON. You don't write any code — the agent does it all. This is the power of a tool-using sequential agent.

Stage 1 success checklist
  • Claude Code confirmed calcom_data.json was created
  • The file exists in your calcom-intel folder
  • Claude Code printed the Stage 1 Complete confirmation with data counts
Step 2 of 5 🟣 Stage 2 — Analysis Agent ⏱ 3 minutes

Stage 2: Intelligence Agent
Find Patterns & Signals

Stage 2 reads the JSON from Stage 1 and reasons about it — categorising issues, spotting trends, identifying what cal.com is prioritising, and surfacing signals relevant to TeamCal AI's roadmap.

🟣 What this agent does

Stage 2 is the intelligence layer. It reads calcom_data.json, applies structured reasoning to categorise and interpret the data, and outputs a structured analysis to calcom_analysis.json. It never touches the GitHub API — it only works with what Stage 1 gave it.

Stage 2 — Analysis Agent Prompt
STAGE_2_ANALYSIS.txt — Paste into the same Claude Code session
You are an intelligence analysis agent. Your job is to read and reason about the data fetched in the previous stage. Input: Read calcom_data.json from the current directory. Produce the following analysis and save it to calcom_analysis.json: 1. REPO_HEALTH: { "stars": number, "open_issues": number, "health_score": "Healthy/Active/Declining" with justification, "release_cadence": "frequent/moderate/slow" based on last 10 releases } 2. TOP_ISSUE_CATEGORIES: Array of {category, count, example_titles[3], urgency: "high/medium/low"} Categorise all open issues into these buckets: - Integrations (Zoom, Slack, calendar sync, webhooks) - Scheduling UX (booking flows, availability, timezone) - AI / Automation (smart scheduling, suggestions, automation) - Mobile / App (iOS, Android, PWA) - Enterprise (SSO, teams, permissions, billing) - Bug fixes (crashes, errors, data issues) - Other 3. HOT_TOPICS: Top 5 most-commented issues with title, comment_count, category 4. PR_VELOCITY: { "avg_files_changed": number, "total_additions": number, "most_active_contributors": top 3 by PR count } 5. COMPETITIVE_SIGNALS: Array of 4–6 observations formatted as: { "signal": "one-sentence observation", "relevance_to_teamcal": "how this relates to TeamCal AI's positioning", "priority": "watch/act/ignore" } 6. ROADMAP_INFERENCE: Based on issue labels and PR activity, what are the top 3 features cal.com is likely shipping in the next 90 days? Save to calcom_analysis.json and print: "✅ Stage 2 Complete — Analysis saved with [N] issue categories and [N] competitive signals"
// Stage 2 reads Stage 1's output. The pipeline is chaining automatically.
🔗

This is the chain in action: Stage 2 has no knowledge of Stage 1's implementation. It only sees calcom_data.json as input and produces calcom_analysis.json as output. Each stage is independently replaceable — you could swap Stage 1 for a different data source and Stage 2 wouldn't change.

Stage 2 success checklist
  • Claude Code confirmed calcom_analysis.json was created
  • The analysis includes issue categories and competitive signals
  • You can see a ROADMAP_INFERENCE section with 3 predicted features
Step 3 of 5 🟢 Stage 3 — Report Agent ⏱ 3 minutes

Stage 3: Dashboard Agent
Render the Intelligence Report

Stage 3 reads the structured analysis from Stage 2 and renders it as a polished, self-contained HTML dashboard — complete with a metrics bar, issue category breakdown, competitive signal cards, and roadmap predictions.

🟢 What this agent does

Stage 3 is the presentation layer. It reads calcom_analysis.json and generates a fully formatted calcom_dashboard.html file that opens in any browser — no server needed, no dependencies, just a clean competitive intelligence report.

Stage 3 — Report Agent Prompt
STAGE_3_REPORT.txt — Paste into the same Claude Code session
You are a report generation agent. Read calcom_analysis.json and generate a polished HTML intelligence dashboard. Save the output as calcom_dashboard.html. Requirements: DESIGN: Clean, professional, light background. Use inline CSS only (no external dependencies). Font: system-ui or sans-serif. Colors: #1A6BFF for primary, #10B981 for positive signals, #EF4444 for risks, #F59E0B for watch items. SECTIONS to include in the HTML dashboard: 1. HEADER: "Cal.com Intelligence Report" with today's date and a subtitle "Competitive Analysis for TeamCal AI — Generated by Sequential AI Agent Pipeline" 2. METRICS ROW: 4 stat cards showing stars, open issues, release cadence, contributor count 3. ISSUE CATEGORIES TABLE: Styled table with columns: Category | Issue Count | Urgency | Example Issues 4. HOT TOPICS: Top 5 most-commented issues as cards with title, comment count, and category badge 5. COMPETITIVE SIGNALS: Grid of signal cards — each card shows the signal text, TeamCal relevance, and a priority badge (🔴 Act / 🟡 Watch / ⚪ Ignore) 6. ROADMAP PREDICTIONS: "What cal.com is likely shipping next 90 days" — 3 items as a numbered list with brief explanation 7. FOOTER: "Generated by a Type 3 Sequential AI Agent Pipeline | Stage 1: GitHub Fetch → Stage 2: Intelligence Analysis → Stage 3: Report Generation | Powered by Claude Code + TeamCal AI" Make it look like a professional report an executive could open and present. No JavaScript required. After saving, print: "✅ Stage 3 Complete — Open calcom_dashboard.html in your browser to see the report"
// The complete pipeline is now done. Three agents, three specialised jobs, one clean output.
Stage 3 success checklist
  • Claude Code confirmed calcom_dashboard.html was created
  • You opened the file in a browser and can see the dashboard
  • The competitive signals section has priority badges
  • The footer correctly credits the 3-stage pipeline
Step 4 of 5 ⏱ 1 minute

Open Your Dashboard &
Extend the Pipeline

Your three-stage sequential AI agent pipeline has run. Open your dashboard, review the output, and see how to expand this pipeline into a fully automated recurring system.

View your output
  • 1
    In your terminal, run: open calcom_dashboard.html (Mac) or start calcom_dashboard.html (Windows)
  • 2
    You should see a complete competitive intelligence dashboard with metrics, issue breakdown, competitive signals, and roadmap predictions — all generated from live GitHub data.
  • 3
    You also have calcom_data.json and calcom_analysis.json — machine-readable files you can feed into Notion, Slack, or any other tool.
What you can do with this pipeline
Swap the repo
Change "calcom/cal.com" in Stage 1 to any public GitHub repo — track any competitor or dependency.
Schedule it weekly
Add a cron job or GitHub Action to run the three stages every Monday morning and email the dashboard.
Add a Stage 4
Push to Slack automatically: "Here are this week's competitive signals from cal.com" — with one more agent stage.
Multi-repo pipeline
Run Stage 1 against multiple repos (cal.com, Calendly API docs, Reclaim) and merge into a single competitive dashboard.
🏆

You just built a real Type 3 Sequential Agent pipeline — three specialised agents chained together, each with a single responsibility, producing live competitive intelligence from a public GitHub repository. This pattern scales to any data source and any output format.

🎉

Workshop Complete!

Your Type 3 Sequential Agent pipeline ran successfully. Here's what you built:

3AI Stages
3JSON Files
1Dashboard
10Minutes
Your reusable sequential agent toolkit
🔵
Fetch Agent PromptWorks for any public GitHub repo — swap "calcom/cal.com" for any target
🟣
Analysis Agent PromptGeneralises to any structured JSON input — not just GitHub data
🟢
Dashboard Agent PromptRenders any analysis.json into a shareable HTML report in seconds
🔗
The Pipeline PatternFetch → Analyse → Report is reusable across any domain: PRs, Slack messages, CRM data, support tickets
Explore the other AI Agent types
  • T1
    Type 1 — Basic Agent with Tools: Gemini + Google Workspace (your morning briefing workshop). Single agent, external integrations.
  • T2
    Type 2 — Tool-Using Agent with MCP: Claude + Jira + Slack + Calendar (your AI PM Agent workshop). Single agent, multiple MCP servers.
  • T3
    Type 3 — Sequential Pipeline (this workshop): Chained specialised agents, each passing output to the next. See Types 4–7 →
💙

Built by TeamCal AI — AI-powered scheduling trusted in 90+ countries. Meet Zara, your AI executive scheduling partner at teamcal.ai/getzaraai →

Welcome — Sequential Agent Architecture Read before starting the sprint