Forem: KrisYing

My Claude Code Buddy Moved Into My MacBook's Notch and I Can't Stop Looking at It

KrisYing — Sun, 05 Apr 2026 05:13:26 +0000

I'm literally losing productivity because I keep expanding my MacBook's notch to check on my AI buddy.

Let me explain.

It Started With a Problem

I run 5-8 Claude Code sessions simultaneously. Different projects, different terminals, total chaos. I was Alt-Tabbing like a maniac, missing permission requests, forgetting which session finished.

Then I built CodeIsland and everything changed.

Wait, Your Notch Does WHAT?

Yes. The MacBook notch. That ugly camera cutout everyone complained about. It's now the most useful part of my screen.

This is my actual workflow. 8 Claude Code sessions. Zero Alt-Tab.

See that tiny green dot and pixel cat at the top? That's CodeIsland. It sits in the notch, watching all my Claude sessions. When I hover over it, it expands into a full control panel:

Every session at a glance. Color-coded terminals. Usage stats. And yes, that's my buddy in the corner.

The Buddy Thing Hit Different

Ok here's where it gets ridiculous. You know Claude Code's /buddy feature? The little ASCII companion that grows with your usage?

Mine is a Legendary Octopus named Kris. PATIENCE stat maxed at 100. Look at this absolute unit:

★★★★★ LEGENDARY. I didn't choose the octopus life.

CodeIsland computes your buddy's stats using the exact same algorithm as Claude Code (Bun.hash + Mulberry32). Same species, same rarity, same stats. It even detects if you've patched your install with any-buddy.

The buddy floats in the bottom-right corner of the panel, doing idle animations. I catch myself just... watching it. This is a problem.

But Actually It's Insanely Useful

Ok let me be serious for a second. Here's what blew my mind:

1. It Knows Which Terminal Tab I'm Looking At

When a Claude session finishes, CodeIsland checks: "Is the user already looking at this session's terminal?" If yes, it doesn't popup. If you're in a different tab, it alerts you.

This works at the workspace level in cmux, session level in iTerm2, and window level in Ghostty. No more "I KNOW, I'M LOOKING AT IT" moments.

2. I Answer Claude's Questions From the Notch

When Claude uses AskUserQuestion, the options appear as buttons right in the notch panel. I click "Option A" and it sends the answer directly to my terminal via cmux send. I don't even switch windows.

3. Usage Stats From the OAuth API

See that? 5h window at 22%, 7d at 30%. CodeIsland reads your OAuth token from macOS Keychain and calls Anthropic's API directly. Zero config. I always know how much headroom I have.

4. Code Diffs in the Chat View

Full conversation history with code diffs, tool calls, and status indicators

Click any session to see the full conversation. Green lines for additions, red for deletions. "Go to Terminal" button at the bottom.

The Setup Takes 30 Seconds

Download from GitHub Releases
Drag to Applications
Run sudo xattr -rd com.apple.quarantine /Applications/Code\ Island.app
Launch. Done.

It auto-installs hooks into your Claude Code config. Zero config needed.

Compact settings with everything you need

The Stack

For the nerds:

Pure Swift + SwiftUI, native macOS
Unix socket for real-time hook events
Anthropic OAuth API for usage stats
AppleScript for terminal detection (cmux/iTerm2/Ghostty/Terminal.app)
macOS Keychain for zero-config auth

It's Free. Like, Actually Free.

No subscription. No telemetry. No commercial intentions. Just a passion project by someone who got tired of Alt-Tabbing.

GitHub: github.com/xmqywx/CodeIsland

Works best with cmux (modern terminal multiplexer on Ghostty), but supports iTerm2, Ghostty, Terminal.app, Warp, VS Code, Cursor, and more.

If you try it, let me know what you think. And if you star the repo... my octopus buddy thanks you. 🐙

Yes, this post was written while CodeIsland was monitoring 3 Claude Code sessions in my notch. No sessions were harmed in the making of this article.

I Turned My MacBook's Notch Into a Control Center for AI Coding Agents

KrisYing — Sun, 05 Apr 2026 05:09:38 +0000

Every developer using Claude Code knows the pain: you have 5+ terminal sessions running, Claude is asking for permission in one tab, waiting for input in another, and you're buried in a third. You Alt-Tab frantically, lose context, and waste time.

So I built CodeIsland — a free, open-source macOS app that turns your MacBook's notch (Dynamic Island) into a real-time dashboard for all your AI coding agents.

The Problem

When you're running multiple Claude Code sessions across different projects, there's no way to see everything at a glance. You're constantly switching between terminals to:

Check which session finished
Approve permission requests
Answer Claude's questions
Monitor usage limits

Multiple Claude Code sessions in cmux, with CodeIsland monitoring everything from the notch

The Solution: Your Notch, Supercharged

CodeIsland lives in your MacBook's notch. When collapsed, it shows a tiny status indicator. When expanded, it becomes a full control panel.

Session list showing active projects, terminal tags, usage stats, and your Claude Code buddy

What You Can Do From the Notch

1. Monitor All Sessions

Every Claude Code session appears in a clean list with:

Color-coded terminal tags (cmux blue, Ghostty purple, iTerm green)
Active sessions highlighted with accent backgrounds
Real-time tool tracking and subagent status

2. Claude Usage Monitoring

Real-time 5h/7d usage percentage pulled directly from Anthropic's OAuth API. No plugins needed — reads your token from macOS Keychain.

5h 22% and 7d 30% usage with progress bars and reset timers

3. Chat History & Code Diffs

Click any session to see the full conversation, including tool calls with status indicators and code diffs with green/red highlighting.

Full conversation view with tool calls, code edits, and "Go to Terminal" button

4. Meet Your Buddy

Full integration with Claude Code's /buddy system. See your companion's species, rarity, stats, and personality.

Legendary Octopus "Kris" with full ASCII art and stat bars

5. Smart Settings

Compact two-column layout with everything you need.

Clean settings with Star & Feedback buttons — v1.8.0

Smart Features That Matter

Smart Popup Suppression

The most annoying thing about notification apps? They interrupt you when you're already looking at the thing they're notifying about.

CodeIsland detects which terminal tab you're currently viewing. If a Claude session finishes in a cmux workspace you're already looking at, it won't popup. It only alerts you about sessions you can't see.

Supported: cmux (workspace-level), iTerm2 (session-level), Ghostty (window-level), Terminal.app (tab-level).

AskUserQuestion Quick Reply

When Claude asks you a multiple-choice question, the options appear as buttons directly in the notch. Click one, and the answer is sent to your terminal automatically via cmux send — no window switching needed.

One-Click Terminal Jump

Every session has a green terminal button. Click it, and CodeIsland finds the exact cmux workspace (or iTerm tab, or Ghostty window) and brings it to front.

Subagent Tracking

When Claude spawns subagents, you see them in real-time with ⚡ badges and collapsible detail views showing each agent's task.

Terminal Support

Terminal	Detection	Jump	Quick Reply	Smart Suppression
cmux	Auto	Workspace-level	✅	Workspace-level
iTerm2	Auto	AppleScript	✅	Session-level
Ghostty	Auto	AppleScript	-	Window-level
Terminal.app	Auto	Activate	✅	Tab-level
Warp	Auto	Activate	-	-
VS Code	Auto	Activate	-	-
+ 5 more	Auto	Activate	-	-

Tech Stack

Swift + SwiftUI — Native macOS, ~70 Swift files
Unix Socket — Hook events from Claude Code via Python bridge
Anthropic OAuth API — Direct usage stats, no middleware
macOS Keychain — Zero-config authentication
AppleScript — Terminal detection and control

Get It

It's completely free and open-source. No commercial intentions — just a passion project.

git clone https://github.com/xmqywx/CodeIsland.git
cd CodeIsland
xcodebuild -scheme ClaudeIsland -configuration Release build

GitHub: github.com/xmqywx/CodeIsland

Works best with cmux — the modern terminal multiplexer built on Ghostty.

If you find it useful, a ⭐ on GitHub would mean the world. It's what keeps us shipping updates.

Built entirely with Claude Code, of course. 🐱

Harness Engineering: Why the Model Is a Commodity and the Infrastructure Is Your Moat

KrisYing — Sun, 15 Mar 2026 20:52:02 +0000

Everyone is chasing the next model upgrade. GPT-5, Claude 4, Gemini Ultra — surely that will be the one that makes our AI agents work properly.

I've been running AI agents in production for months. Here's what I've learned: the model doesn't matter nearly as much as what you put around it.

The Uncomfortable Truth

Two teams use the same Claude model. One gets mediocre results. The other builds a system that runs 24/7, learns from its mistakes, and gets measurably better every week.

The difference isn't the model. It's the harness.

What Is Harness Engineering?

Harness Engineering is the discipline of building infrastructure that wraps, constrains, and amplifies AI models.

Traditional thinking: Better Model → Better Results
Harness Engineering: Same Model + Better Harness → Dramatically Better Results

Think of it like Formula 1. The engine matters, sure. But the chassis, aerodynamics, tires, telemetry, pit strategy — that's what wins championships. The engine is table stakes.

The Five Harnesses

After building Evolve, an open-source control plane for AI agents, I've identified five types of harness:

1. Prompt Harness

Not a static system prompt. A dynamic assembly that builds the optimal prompt based on:

Current task context
Relevant historical knowledge (auto-injected)
Active constraints and permissions
Agent identity and behavioral rules

Every time the agent starts, it gets a prompt that's tailored to right now. Not a generic instruction set — a living document.

2. Output Harness

Captures, validates, and routes agent outputs. In Evolve, the agent must call Self-Report APIs:

# Not optional. No report = work doesn't exist.
curl -X POST /api/agent/heartbeat -d '{"activity":"coding","progress_pct":40}'
curl -X POST /api/agent/discovery -d '{"title":"Found rate limit","priority":"high"}'
curl -X POST /api/agent/review -d '{"learned":["Never use pkill -f"]}'

This does two things: (1) gives you real-time visibility, and (2) feeds the knowledge loop.

3. Constraint Harness

Enforces boundaries at runtime. Toggle from a dashboard — no restart needed:

Can the agent browse the web? ✅/❌
Can it push to GitHub? ✅/❌
Can it spend money? ❌ (always blocked)
Can it install packages? ✅/❌

Constraints are injected into the prompt. The agent knows its boundaries and respects them.

4. Runtime Harness

Keeps the agent alive:

Watchdog: 10-second health checks. Hung process? Auto-revived.
Heartbeat monitor: 5 min silence → nudge. 15 min → intervention.
Crash recovery: --resume with knowledge injection. The agent picks up where it left off, smarter than before.

This is the difference between a script that runs once and a system that survives.

5. Observation Harness

A second AI reviews the first AI's work:

Reads full conversation logs (JSONL)
Extracts key decisions and tool calls
Analyzes efficiency, correctness, and instruction adherence
Generates improvement suggestions

The reviewer uses a cheaper model. The cost is negligible. The insight is invaluable.

The Knowledge Loop: Where It All Comes Together

The real magic happens when these harnesses work together:

Agent works → Output Harness captures lessons
                    ↓
        Secondary LLM scores and refines
                    ↓
        Layered knowledge base stores them:
          • Permanent (critical lessons)
          • Recent (30-day TTL)
          • Task-specific (current context)
                    ↓
        Prompt Harness injects on next startup
                    ↓
        Agent is measurably smarter

This is a closed loop. The agent doesn't just execute — it evolves.

Why This Matters Now

Models are converging. GPT-4, Claude, Gemini — they're all roughly comparable for most tasks. The differentiator isn't which model you use. It's how well you harness it.

Companies investing in better models are playing the wrong game. Invest in better harnesses instead:

Better prompt engineering → Prompt Harness
Better observability → Output + Observation Harness
Better safety → Constraint Harness
Better reliability → Runtime Harness

Getting Started

Evolve is open source (MIT). It implements all five harnesses for Claude Code agents.

git clone https://github.com/xmqywx/Evolve.git
cd Evolve && python -m venv .venv
.venv/bin/pip install -r requirements.txt
cd web && npm install && npm run build && cd ..
.venv/bin/python run.py

But even if you don't use Evolve, start thinking about your AI infrastructure as a harness. What are you wrapping around your model? What constraints are you enforcing? How does your agent learn from yesterday?

The model is a commodity. The harness is your moat.

What does your AI agent infrastructure look like? I'd love to hear about your approach to these problems.

I Built a Control Plane for My AI Agent — Because It Kept Making the Same Mistakes

KrisYing — Sun, 15 Mar 2026 20:52:01 +0000

I run a Claude agent 24/7. It writes code, deploys services, manages my side projects. Sounds cool, right?

Except it kept doing dumb things. And I'd only find out after the damage was done.

The Three Problems Nobody Talks About

When you let an AI agent run autonomously, you quickly hit three walls:

1. You have no idea what it's doing.
You're tailing logs, scrolling through terminal output, trying to piece together what happened while you were asleep. The agent ran for 8 hours. What did it accomplish? Nobody knows.

2. It repeats the same mistakes.
Last week it used pkill -f and crashed my system. I told it not to. Next session? Same mistake. Every conversation starts from zero.

3. When it does something wrong, you find out too late.
It spent 3 hours going in circles on a task that should have taken 20 minutes. It installed packages I explicitly said not to. It pushed broken code. By the time you notice, it's already done.

The Fix: Make the Agent Report Its Own Status

I built Evolve — a control plane for autonomous AI agents.

The key insight: don't monitor the agent from outside. Make it monitor itself.

# The agent reports: "I'm coding, 40% done"
curl -X POST $EVOLVE_URL/api/agent/heartbeat \
  -d '{"activity":"coding","description":"implementing auth module","progress_pct":40}'

# The agent reports: "I discovered something important"
curl -X POST $EVOLVE_URL/api/agent/discovery \
  -d '{"title":"Rate limit found","content":"Max 3 posts/day","priority":"high"}'

# The agent reports: "Here's what I learned today"
curl -X POST $EVOLVE_URL/api/agent/review \
  -d '{"accomplished":["API integration"],"learned":["Use MD5 not SHA256"]}'

The rule is simple: No report = work doesn't exist. This is baked into the agent's prompt. It must call these APIs, or the work doesn't count.

6 reporting endpoints cover everything: Heartbeat, Deliverable, Discovery, Workflow, Upgrade Proposal, and Review.

The Evolve Dashboard — real-time agent status, system health, active sessions, and recent tasks at a glance.

The Part That Changed Everything: Knowledge That Persists

This is the core innovation. Most agent frameworks start from zero every conversation. Evolve creates a closed-loop learning system:

Agent makes mistake → Reports via review API
        ↓
LLM evaluates: "This is a 10/10 critical lesson"
        ↓
Stored in layered knowledge base:
  • Permanent (score ≥8): Core lessons, never expire
  • Recent (5-7): Useful but temporal, 30-day TTL
  • Task: Matched to current work context
        ↓
Next startup: Injected into agent's prompt
        ↓
Agent never makes that mistake again

The key design decisions:

Refinement, not storage. A secondary LLM scores each lesson (1-10), distills it to one sentence, and tags it. Raw data goes in, actionable knowledge comes out.
Three-layer injection. Only the most relevant knowledge enters the prompt. Not everything — that would blow up the context window.
Auto-expiry. Low-value knowledge expires after 30 days. The knowledge base stays lean.

AI Reviewing AI

One agent works. Another reviews its work.

The Supervisor page — daily analysis reports with heartbeat, deliverable, and discovery counts.

Click "Analyze" in the dashboard → Evolve reads the full conversation log (JSONL) → extracts key actions → compresses to ~6000 chars → sends to a secondary LLM for analysis:

Was each decision reasonable?
Any idle loops or wasted effort?
Did it follow instructions?
Efficiency score + improvement suggestions

This costs almost nothing because the reviewer is a cheaper model, not Claude.

The 24/7 Survival Engine

The agent doesn't just run — it survives:

Watchdog: Health check every 10 seconds. Hung? Auto-revived.
Heartbeat detection: 5 min silence → gentle nudge. 15 min → context-aware intervention.
Crash recovery: Restart with --resume, inject historical knowledge, continue seamlessly.
Web terminal: Operate the tmux session from your browser. No SSH needed.

Runtime Permission Controls

Toggle what your agent can do from the dashboard. No restart, no code changes:

Capability toggles and behavior settings — control autonomy level, risk tolerance, and more.

Extensions Management

Full visibility into skills, MCP servers, and plugins — with auto-tagging and source tracking.

Harness Engineering

I call this approach Harness Engineering — building infrastructure that wraps, constrains, and amplifies AI models.

Traditional: Better Model → Better Results
Harness Eng: Same Model + Better Harness → Dramatically Better Results

The model is a commodity. Two teams using the same Claude will get wildly different results based on their harness quality. Evolve is that harness.

Try It

git clone https://github.com/xmqywx/Evolve.git
cd Evolve
python -m venv .venv && .venv/bin/pip install -r requirements.txt
cd web && npm install && npm run build && cd ..
cp config.yaml.example config.yaml
.venv/bin/python run.py
# Visit http://localhost:3818

Stack: Python/FastAPI backend, React/TypeScript frontend, SQLite, xterm.js, Claude Code runtime.

MIT licensed. GitHub →

If you're running AI agents in production and tired of babysitting them, give Evolve a try. I'd love to hear how you're solving these same problems.

How I'm Building a One-Person AI Automation Agency in 2026 (Tools, Stack, Revenue)

KrisYing — Wed, 11 Mar 2026 22:33:30 +0000

In 2026, one developer with AI tools can deliver what used to require a 5-person agency.

I'm not saying this as hype. I'm saying it because I've been living it. Over the past few months I've built 25 n8n automation templates, published 2 MCP servers, packaged 17 Claude Code skills, and started landing Upwork clients — all as a solo developer.

This is my honest breakdown of how the business works, what the stack looks like, and what the numbers actually are right now.

The Core Insight

Traditional automation agencies need:

A project manager to scope work
A developer to build the automation
A QA person to test it
A copywriter to document it
A salesperson to find clients

With Claude Code + n8n + MCP servers, one person covers all five roles. Not perfectly. But well enough to deliver real value to real clients.

That's the wedge. And I'm using it.

The Stack

Claude Code — My Development Partner

Claude Code is Anthropic's official CLI. It runs in your terminal, reads your codebase, and helps you build at a pace that genuinely feels like having a senior developer beside you.

I use it for:

Scaffolding new n8n workflow logic before building in the UI
Writing TypeScript MCP servers from scratch
Generating Shopify API integrations
Debugging webhook failures
Writing client-facing documentation

The key shift is treating Claude Code as a collaborator, not a code generator. You're still the architect. It handles the boilerplate, the syntax, the "how do I do this in TypeScript again" questions.

n8n — The Automation Engine

n8n is my core delivery tool. It's open-source, self-hostable, and has the best balance of power vs. usability I've found. Clients can actually look at workflows and understand them, which matters for handoff.

My workflow with n8n:

Client describes a business problem
I map it to an automation pattern I've already built
I adapt one of my 25 templates to their specific setup
Deploy, test, document, hand off

Having a library of battle-tested templates means I can deliver a project in hours instead of days. That's my competitive advantage.

MCP Servers — The Integration Layer

Model Context Protocol is how AI agents connect to real tools. I've built two production MCP servers:

Shopify MCP Server: 16 tools for managing products, orders, inventory, customers, and analytics — all accessible directly from Claude
Google Sheets MCP Server: 14 tools for reading, writing, formatting, and querying spreadsheets — filling a real gap in the market

MCP servers turn Claude into a genuine business tool. Instead of copy-pasting data between systems, clients can ask their AI agent to "pull last week's orders and update the inventory sheet" and it just works.

What I Actually Sell

1. Custom Automation Projects (Upwork)

This is the fastest path to cash. Clients post jobs, I apply, I deliver.

My positioning: "AI-powered automation using n8n and Claude Code." I'm not just an n8n developer — I bring AI into the workflow itself.

Typical projects:

Order processing automation ($300-800)
AI-powered email responders ($400-1200)
Lead scoring pipelines ($500-1500)
Voice agent integrations ($800-2000)
MCP server development ($1000-3000)

Rates: $40-80/hr or fixed price. Still building the profile, but the pipeline is real.

Upwork profile

2. n8n Template Pack (Digital Product)

I packaged 25 production-ready n8n templates into a bundle covering e-commerce, content, operations, and advanced AI use cases.

Each template is:

Fully documented
Ready to import
Covers a real business use case

The bundle is live on Gumroad. Having it there also serves as a portfolio — clients can see the scope of what I've built before hiring me.

AI Business Automation Pack on Gumroad

3. MCP Server Marketplace

Both MCP servers are published and listed on MCP directories. The goal is passive income from developers who need these integrations without building from scratch.

The Google Sheets MCP fills a genuine gap — there's no dominant solution in that space yet.

4. Claude Code Skills

17 packaged Claude Code skills covering git workflows, code review, API scaffolding, project health checks, freelance proposal writing, content pipelines, and more.

Skills are a new distribution format — portable, composable, shareable. Think of them as specialized AI workflows you can install and invoke.

Revenue Channels (The Four-Channel Model)

I'm not betting everything on one channel. Here's the split:

Channel	Type	Timeline
Upwork freelancing	Active income	Immediate
Digital products (Gumroad)	Passive income	Medium
MCP marketplace	Passive income	Medium
Content marketing	Lead gen	Long term

The theory: freelancing pays the bills now while products build passive income over time. Content drives inbound for both.

Real Numbers (Early Stage, Honest)

I'll be direct: this is early. I'm not writing this from a beach with a $20K MRR dashboard.

What exists right now:

25 n8n templates built and packaged
2 MCP servers compiled and listed
17 Claude Code skills ready
Upwork profile live, proposals going out
Gumroad products created (awaiting payment setup to publish)
6 dev.to articles published (including this one)
Multiple freelance platforms set up (Upwork, Fiverr, PeoplePerHour, Freelancer.com)

What I'm targeting:

$2K-5K/mo in 90 days from freelancing
$500-1K/mo in 6 months from digital products
$200-500/mo in 6 months from MCP marketplace

The blueprint is sound. Execution is the variable.

Lessons Learned So Far

1. Marketing is the actual job

I spent months building things. Products that no one knew existed. The hard truth: a mediocre product with great distribution beats a great product with no distribution every time.

Now I spend more time on:

Writing articles (like this one)
Submitting to directories
Posting proposals
Cold outreach to potential clients

Building is the fun part. Marketing is the job.

2. Start with services, then productize

Every template in my bundle started as something I built for a real use case. Every MCP server solves a problem I actually hit. Services first forces you to build things that work in the real world, not things that are interesting in theory.

Once you have something proven, package it. Then you're selling the same work multiple times.

3. Templates accelerate everything

Having a library of working templates means:

Faster project delivery (hours not days)
Lower risk for clients (they can see what they're getting)
Easier proposals (I know exactly what it takes)
Passive income channel (sell the templates directly)

If you're doing automation work and not building a template library, you're leaving money on the table.

4. The niche matters more than the tool

"I do n8n automation" is a commodity. "I build AI-powered Shopify automation systems for e-commerce operators" is a positioning.

The more specific you are, the easier it is to find clients, write proposals, and charge a premium. I'm still refining mine, but the direction is e-commerce + AI + Claude Code.

5. MCP is undermonetized right now

The MCP ecosystem is exploding — 97M+ monthly SDK downloads, 10K+ active servers, 8 new directories launched in the last 6 months. But less than 5% of MCP servers are monetized.

That gap is an opportunity. Building MCP servers now, while the ecosystem is young, is the equivalent of building Shopify apps in 2012. Most developers are ignoring it because the monetization infrastructure is still forming.

The Tools List

For anyone who wants to replicate this:

Development

Claude Code (Anthropic) — AI pair programming
n8n (self-hosted or cloud) — workflow automation
TypeScript — MCP server development
Node.js/Express — API backends

Business Infrastructure

Upwork — freelance clients
Gumroad — digital product sales
Polar.sh — developer-focused payments (4% vs Gumroad's 10%)
GitHub — open source + portfolio

Distribution

Dev.to — technical content
MCP directories (mcp.so, glama.ai, PulseMCP) — MCP server discovery
n8n marketplaces (n8nmarket.com, ManageN8N) — template distribution
Fiverr, PeoplePerHour, Freelancer.com — freelance reach

AI Services

DeepSeek API — cost-effective OpenAI-compatible API
OpenAI API — when clients need it specifically

What's Next

The immediate focus is converting the infrastructure into revenue:

Get first Upwork client (proposals going out daily)
Publish Gumroad bundle (payment method setup pending)
Get MCP servers listed on top 5 directories
Publish this article and the five others in the backlog
Submit to Shopify App Store (0% commission to $1M — hard to ignore)

If you're building something similar — a solo dev agency, a product business, anything in the automation space — I'd genuinely like to compare notes.

Resources

Building in public. Early stage. Real numbers when there are real numbers to share.

📦 Get My Templates

Want these templates ready to use? Check out my complete collection of

25 production-ready n8n automation templates — ready to deploy immediately.

👉 Get the n8n Templates Bundle ($10)

Perfect for automation engineers, consultants, and anyone looking to accelerate their n8n projects with battle-tested workflows.

I Built 5 Custom GPTs as Lead Magnets — Here's the Strategy Behind Each One

KrisYing — Wed, 11 Mar 2026 22:27:57 +0000

The GPT Store has 3 million+ custom GPTs. Most make nothing. But the ones that work? They're not trying to monetize inside the GPT Store — they're funnels to something bigger.

I built 5 custom GPTs that each serve as a free demo of my paid n8n automation templates ($149 bundle). Here's the exact strategy.

The Funnel: Free GPT → Paid Product

User discovers GPT on GPT Store
       ↓
Uses it for free (gets real value)
       ↓
GPT mentions: "Want this automated 24/7?
I have an n8n template that does this."
       ↓
User clicks link → Gumroad → $149 bundle

The key insight: the GPT gives a taste of what the full automation does. The GPT requires manual input each time. The n8n template runs automatically, 24/7.

GPT 1: E-Commerce AI Advisor

What it does: Analyzes your Shopify/e-commerce store and identifies automation opportunities.

The hook: User describes their business → GPT outputs a prioritized list of automations with ROI estimates → each recommendation maps to a specific template in the bundle.

Sample conversation:

User: "I run a Shopify store selling organic skincare. 200 orders/month, 3 customer service emails/day."

GPT: "Based on your volume, here are your top 3 automation opportunities:

AI Email Auto-Responder (save 10+ hrs/week) — classify and draft responses to those 3 daily emails automatically

Abandoned Cart Recovery (recover 10-15% of carts) — at 200 orders/month, that's 20-30 recovered sales

AI Social Media Content (save 8+ hrs/week) — generate daily posts from your product catalog"

Why it converts: The advice is genuinely useful AND specific to their business. They can see the exact ROI. The next logical step is "how do I actually build this?" → template bundle.

GPT 2: AI Workflow Architect

What it does: Designs custom n8n/automation workflow blueprints.

The hook: User describes what they want automated → GPT outputs a complete workflow diagram with node types, triggers, and data flow → mentions that pre-built templates are available.

This GPT positions me as the expert to hire if they want custom implementation.

GPT 3: Contract Risk Analyzer

What it does: Analyzes contract text for risky clauses, missing provisions, and red flags.

The hook: User pastes contract → GPT does a basic risk analysis → mentions that the full AI Contract Reviewer template does this automatically at scale, scoring every contract 1-100.

Why vertical GPTs work better: Legal professionals have budget. They're used to paying for tools. A free contract analyzer that shows value → paid template for their firm → potential consulting engagement.

GPT 4: Resume Screener Pro

What it does: Evaluates resumes against job descriptions and generates interview questions.

The hook: HR teams paste resume + JD → GPT scores the candidate → mentions the full template processes 100 resumes in 30 minutes automatically.

GPT 5: Meeting Notes Summarizer

What it does: Extracts decisions, action items, and key topics from meeting transcripts.

The hook: User pastes transcript → GPT extracts structured summary → mentions the template does this automatically via webhook integration with Zoom/Teams.

Design Principles

1. Give Real Value First

The GPT must be genuinely useful, not just an ad. If someone uses it once and gets value, they'll come back — and eventually convert.

2. Natural Upsell, Not Pushy

The mention of paid products comes at the END, framed as "if you want this to run automatically, here's how." Never gate the core value.

3. Target Verticals

Generic "AI assistant" GPTs get lost. "Contract Risk Analyzer" and "Resume Screener" target specific professionals who have budget and urgency.

4. Include Brand Consistently

Every GPT ends responses with: "Built by Kris — AI Automation Engineer" — building recognition across all touchpoints.

Publishing Checklist

[ ] Create GPT on chat.openai.com/gpts/create
[ ] Write clear description (include keywords for GPT Store search)
[ ] Add 4 conversation starters
[ ] Set to "Public" for GPT Store listing
[ ] Test with 5 sample conversations
[ ] Share link on LinkedIn, Twitter, relevant subreddits

Expected Results

Being realistic:

Each GPT might get 50-200 users/month
2-5% click through to Gumroad
5% of those convert

That's 0.5-2 sales per GPT per month without any marketing spend. With 5 GPTs, that's 2.5-10 sales/month = $370-$1,490/month from free GPTs alone.

The real value is compounding distribution: every GPT Store listing, every MCP directory submission, every Dev.to article, every Upwork profile — they all cross-link and reinforce each other.

📦 Get My Templates

Want these templates ready to use? Check out my complete collection of

25 production-ready n8n automation templates — ready to deploy immediately.

👉 Get the n8n Templates Bundle ($10)

Perfect for automation engineers, consultants, and anyone looking to accelerate their n8n projects with battle-tested workflows.

Resources:

[25 AI Automation Templates — $149 bundle][GUMROAD_LINK]
[My MCP Servers on npm][NPM_LINK]
Available for custom automation: [Upwork][UPWORK_LINK]

MCP Servers Are the New SaaS: How I'm Monetizing AI Tool Integrations in 2026

KrisYing — Wed, 11 Mar 2026 22:27:51 +0000

The Model Context Protocol has hit 8 million downloads with 85% month-over-month growth. Over 11,000 MCP servers exist. Less than 5% are monetized.

This is the equivalent of the early App Store — before everyone figured out how to charge for apps.

I've built 2 MCP servers (30 tools total) and I'm going to walk you through exactly how the MCP economy works, what's selling, and how to get in before it's crowded.

What is MCP (30-Second Version)

MCP lets AI agents (Claude, Cursor, Windsurf, Cline) call external tools. Instead of the AI just generating text, it can:

Query your Shopify store
Update a Google Sheet
Search your CRM
Process an invoice

Think of it as APIs, but for AI agents. You build the server once, and any MCP-compatible client can use it.

The Business Models That Work

1. Freemium (21st.dev model)

21st.dev hit $10K MRR in 6 weeks with zero marketing. Their model:

Free tier: basic UI component generation
Paid tier ($20/mo): premium components, priority access

This works because developers discover the tool organically through MCP directories, get hooked on the free tier, then upgrade.

2. Usage-Based (MCPize model)

MCPize lets you deploy MCP servers and charge per tool call:

You set the price per invocation
They handle billing, auth, deployment
You get 85% revenue share

Best for servers that provide real-time data or expensive API calls.

3. Lead Generation (My model)

I publish MCP servers for free on npm. Each server's README links to:

My Upwork profile (freelance work)
My template bundle on Gumroad ($149)
My consulting page

The MCP server is the top of funnel. Someone discovers my Shopify MCP server, sees I also sell n8n templates for e-commerce, and buys the bundle.

What I Built: 2 MCP Servers

Shopify Store MCP (16 tools)

// Tools include:
- get_products, create_product, update_product
- get_orders, get_order_details
- manage_inventory, adjust_inventory
- get_customers, search_customers
- get_analytics, get_sales_report
// + 5 more

Why it sells: Every Shopify developer wants to let AI manage their store. Claude can now check inventory, process orders, update products — all through natural language.

Google Sheets MCP (14 tools)

// Tools include:
- read_range, write_range, append_rows
- create_spreadsheet, get_spreadsheets
- format_cells, create_chart
- add_sheet, delete_sheet
// + 5 more

Why it sells: Google Sheets is the universal business database. AI agents that can read and write to Sheets can automate almost any business process.

How to Build Your First MCP Server

The stack is simple:

npm init -y
npm install @modelcontextprotocol/sdk

Every MCP server follows this pattern:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

const server = new McpServer({
  name: "your-server",
  version: "1.0.0",
});

server.tool(
  "tool_name",
  "Description of what this tool does",
  { param: z.string().describe("Parameter description") },
  async ({ param }) => {
    // Your logic here
    const result = await callExternalAPI(param);
    return { content: [{ type: "text", text: JSON.stringify(result) }] };
  }
);

That's it. Each server.tool() call registers one tool that AI agents can call.

Where to List (Distribution Strategy)

Platform	Type	Why
npm	Package registry	Developers find you via `npm search`
mcpmarket.com	Directory	Curated, high-quality listings
pulsemcp.com	Directory	8,590+ servers, good discovery
mcp.so	Directory	Clean UI, growing traffic
mcpservers.org	Directory	"Awesome MCP Servers" list
Cline Marketplace	IDE integration	Millions of Cline users
Smithery.ai	Registry	Developer-focused
MCPize	Monetized hosting	85% revenue share

Pro tip: Submit to ALL of them. Each listing is a backlink and a discovery channel. The servers that appear on 5+ directories get 10x more installs.

The Money Math

Let's be conservative:

Free MCP server gets 500 installs/month
2% check out your paid products
10 visitors/month to your Gumroad page
5% conversion rate = 0.5 sales/month per server

At $149/bundle, that's ~$75/month per MCP server in passive income. With 5 servers, that's $375/month — just from the lead gen angle.

Add MCPize monetization (even $0.01/call), and a server with 10,000 calls/month adds another $85/month.

What's Next

I'm building MCP servers for:

Slack (workspace management for AI agents)
n8n (let AI trigger n8n workflows via MCP)
Stripe (payment processing for AI agents)

The window is open now. In 12 months, every major SaaS company will have their own official MCP server. The opportunity for indie developers is RIGHT NOW.

My toolkit:

25 n8n AI workflow templates ([bundle on Gumroad][GUMROAD_LINK])
2 MCP servers on npm (30 tools)
17 Claude Code skills
Available for hire: [Upwork profile][UPWORK_LINK]

What MCP server are you building? Drop a comment below.

📦 Get My Templates

Want these templates ready to use? Check out my complete collection of

25 production-ready n8n automation templates — ready to deploy immediately.

👉 Get the n8n Templates Bundle ($10)

Perfect for automation engineers, consultants, and anyone looking to accelerate their n8n projects with battle-tested workflows.

MCP Servers Explained: How to Connect AI Agents to Any Business Tool

KrisYing — Wed, 11 Mar 2026 22:22:05 +0000

MCP Servers Explained: How to Connect AI Agents to Any Business Tool

The Model Context Protocol (MCP) is the biggest shift in AI tooling since function calling. If you build AI applications, you need to understand MCP — it's how AI agents will interact with the real world.

I've built 2 MCP servers with 30 tools between them. Here's everything I learned.

What Problem Does MCP Solve?

Before MCP, connecting an AI agent to a business tool meant:

Write custom API integration code
Define tool schemas for the specific AI model
Handle authentication, rate limiting, error handling
Repeat for every new tool and every new AI model

MCP standardizes this. Build one MCP server, and any AI client (Claude, Cursor, Windsurf, custom agents) can use your tools.

Think of it like USB for AI — one connector, universal compatibility.

Architecture in 60 Seconds

AI Client (Claude/Cursor) ←→ MCP Protocol ←→ Your MCP Server ←→ Business API

Your MCP server exposes tools (functions the AI can call), resources (data the AI can read), and prompts (pre-built conversation templates).

Building a Real MCP Server

Here's the structure of my Shopify MCP Server (16 tools):

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({
  name: 'shopify-store-mcp',
  version: '1.0.0'
}, {
  capabilities: {
    tools: {}
  }
});

// Define tools
server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'get_products',
      description: 'List products from the Shopify store with optional filters',
      inputSchema: {
        type: 'object',
        properties: {
          limit: { type: 'number', description: 'Max products to return (default 10)' },
          status: { type: 'string', enum: ['active', 'draft', 'archived'] }
        }
      }
    },
    // ... 15 more tools
  ]
}));

// Handle tool calls
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  switch (name) {
    case 'get_products':
      const products = await shopifyClient.get('products', args);
      return { content: [{ type: 'text', text: JSON.stringify(products) }] };
    // ... handle other tools
  }
});

// Start server
const transport = new StdioServerTransport();
await server.connect(transport);

My 2 MCP Servers

Shopify Store MCP (16 Tools)

Products: list, get, create, update, delete
Orders: list, get, create, fulfill, cancel
Inventory: get levels, adjust quantities
Customers: list, get, create, search
Analytics: get order stats, revenue summaries

Google Sheets MCP (14 Tools)

Spreadsheets: create, list, get
Data: read range, write range, append rows, clear range
Sheets: add sheet, delete sheet, rename
Formatting: set column widths, merge cells
Search: find values across sheets

What Makes a Good MCP Server

1. Clear Tool Descriptions

AI agents read your tool descriptions to decide when to use them. Be specific:

// Bad
"description": "Gets data"

// Good
"description": "List products from the Shopify store. Returns product title, price, inventory quantity, and status. Supports filtering by status (active/draft/archived) and pagination with limit parameter."

2. Defensive Error Handling

AI agents will pass unexpected inputs. Handle everything:

case 'update_product':
  if (!args.productId) {
    return { content: [{ type: 'text', text: 'Error: productId is required' }] };
  }
  try {
    const result = await shopifyClient.put(`products/${args.productId}`, args);
    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
  } catch (err) {
    return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
  }

3. Reasonable Defaults

Don't require parameters that have obvious defaults:

properties: {
  limit: { type: 'number', description: 'Max results (default: 10)', default: 10 },
  sortBy: { type: 'string', description: 'Sort field (default: created_at)', default: 'created_at' }
}

Monetization

MCP servers have multiple revenue paths:

Channel	Model	Potential
npm (free)	Lead generation	Credibility + GitHub stars
MCPize	Per-call (85% share)	$100-$10K/mo
Cursor Marketplace	Free (visibility)	User acquisition
Freelance	Custom MCP dev	$500-$5,000/project
Fiverr/Upwork	MCP gigs	$95-$500/gig

The market is early: MCP downloads are up 85% month-over-month, but less than 5% of servers are monetized. There's a window for early movers.

Getting Started

Pick a business tool your clients use (CRM, accounting, project management)
Use the @modelcontextprotocol/sdk npm package
Start with 3-5 tools that cover the most common operations
Test with Claude Desktop or Cursor
Publish to npm and submit to MCP directories

The MCP ecosystem is growing fast. The developers who build useful servers now will own the distribution when the market matures.

I build MCP servers and AI automation systems. Check out my [Shopify MCP Server][GITHUB_LINK] and [Google Sheets MCP Server][GITHUB_LINK_2] on GitHub.

How I Built 20 AI Automation Templates That Actually Work in Production

KrisYing — Wed, 11 Mar 2026 22:21:59 +0000

How I Built 20 AI Automation Templates That Actually Work in Production

I spent the last month building 20 n8n workflow templates that integrate AI into real business processes. Not demos. Not "hello world" chatbots. Production systems that handle real data, fail gracefully, and run 24/7.

Here's what I learned about building AI automations that people actually pay for.

The Problem with Most AI Automations

90% of AI automation tutorials show you this:

Connect to ChatGPT
Send a prompt
Get a response
Done!

That's a toy. Production AI automation needs:

Input validation (garbage in, garbage out)
Structured output parsing (not raw text)
Error handling (APIs fail, LLMs hallucinate)
Conditional routing (different responses need different actions)
Downstream integrations (Slack alerts, spreadsheet logging, email notifications)

My Template Architecture

Every template follows the same proven pattern:

Trigger → Validate → AI Process → Parse JSON → Route → Action → Log

1. Trigger (Webhook or Schedule)

Most templates use a Webhook trigger for on-demand processing. One template (Upwork Job Hunter) uses a Schedule Trigger to run every 4 hours automatically.

2. Validate Input

Before sending anything to an AI, validate the input. Check required fields, sanitize text, reject empty payloads. This prevents wasting API credits on bad requests.

3. AI Processing (HTTP Request Node)

I use n8n's HTTP Request node to call any OpenAI-compatible API:

{
  "model": "deepseek-chat",
  "messages": [
    {"role": "system", "content": "You are a [specialist]. Output valid JSON only."},
    {"role": "user", "content": "Process this: {{$json.inputData}}"}
  ],
  "temperature": 0.3
}

Key decisions:

Low temperature (0.3) for structured tasks, higher (0.7) for creative tasks
System prompt demands JSON output — no markdown, no explanations
DeepSeek for cost optimization ($0.001/request vs $0.01+ for GPT-4)

4. Parse JSON Response

The AI returns a JSON string inside choices[0].message.content. A Code node extracts and parses it:

const content = $input.first().json.choices[0].message.content;
const cleaned = content.replace(/```
{% endraw %}
json\n?/g, '').replace(/
{% raw %}
```\n?/g, '');
return [{ json: JSON.parse(cleaned) }];

5. Conditional Routing (IF Node)

Route based on AI output:

Lead score >= 70? → Hot lead notification
Resume score >= 80? → Qualified candidate alert
Sentiment negative? → Escalate to human

6. Actions

Slack: Alert team members in real-time
Google Sheets: Log every result for analysis
Email: Send formatted reports
Webhook: Trigger downstream systems

5 Templates That Sell Best

1. AI Lead Scorer

Input: Lead data (name, company, interaction history)
Output: Score 1-100, recommended action, talking points

Why it sells: Every business has leads. Nobody has time to qualify them all manually. This saves 5-8 hours/week per salesperson.

2. AI Content Repurposer

Input: Blog post or article
Output: 5 tweets, LinkedIn post, newsletter intro, video script outline

Why it sells: Content teams create one piece and need it everywhere. This turns 1 article into 8+ pieces of content automatically.

3. AI Customer Support Router

Input: Customer message
Output: Category, priority, sentiment, suggested response, routing decision

Why it sells: Reduces first-response time by 60%. Routes urgent issues to humans, handles FAQ automatically.

4. AI Resume Screener

Input: Resume text + job requirements
Output: Technical fit score, experience score, interview questions, hire/pass recommendation

Why it sells: HR teams screening 100+ resumes per role. This reduces screening time from 8 hours to 30 minutes.

5. Multi-Agent Research Pipeline

Input: Research topic
Output: Synthesized report from 3 parallel AI "analysts"

Why it sells: Most complex template (uses n8n's Merge node for parallel execution). Produces research reports that would take a human 4-6 hours in under 2 minutes.

Monetization Strategy

I sell templates in 3 tiers:

Individual templates: $19-$29 each
Category bundle (5 templates): $49
Complete pack (20 templates): $99-$129

The complete pack has the best conversion rate because the per-template cost drops to $5-6.

Where to Sell

Gumroad (easiest setup, 10% fee)
Neura Market (90% seller share — best rate!)
n8n community (free exposure + credibility)
ComeUp ($1 flat commission!)

Lessons Learned

Structured output is everything. Force JSON output in system prompts. Parse defensively. Have fallbacks.
DeepSeek is 10x cheaper than GPT-4 for most structured tasks with comparable quality. Use it for production, save OpenAI for complex reasoning.
Demo mode matters. Every template has a demo mode that returns realistic sample data when no API key is configured. This lets buyers test the workflow before connecting their own API.
Error handling is the difference between a template someone uses once and one they run in production. Every template handles API failures, empty responses, and malformed JSON.
Documentation sells templates. Clear descriptions of every node, what it does, and how to customize it. People pay for the workflow AND the knowledge.

Get Started

If you want to build sellable n8n templates:

Pick a business process people complain about
Build the automation with the 7-node pattern above
Add demo mode for easy testing
Write clear documentation
List on 2-3 marketplaces

The AI automation market is growing 25-30% annually. There's room for everyone.

I'm building AI automation systems for businesses. If you need custom n8n workflows, MCP servers, or AI agents, check out my [full template pack on Gumroad][GUMROAD_LINK].

Multi-Agent AI in n8n: 3 Parallel Agents for Competitive Intelligence

KrisYing — Wed, 11 Mar 2026 22:16:16 +0000

Agentic AI is the hottest topic in software development right now. Every week there is a new framework — LangChain, CrewAI, AutoGen, LlamaIndex Workflows — promising to make multi-agent systems accessible. But if you are already using n8n for automation, you can build a surprisingly capable multi-agent pipeline today with no new dependencies, no Python environments, and no infrastructure changes.

This article walks through a competitive intelligence pipeline that spins up three specialized AI agents, runs two of them in parallel, then synthesizes their outputs into a structured research report. The whole thing triggers from a webhook and logs results to Google Sheets.

Section 1: The Architecture

Here is the full workflow at a glance:

Webhook Trigger
    └── Validate Request (Code node)
            ├── Agent 1: Market Analyst ──────────┐
            │                                      ├── Merge Node (waitForAll)
            └── Agent 2: Competitor Analyst ───────┘
                                                        └── Code Node: Merge Results
                                                                └── Agent 3: Strategy Synthesizer
                                                                        └── Respond to Webhook
                                                                                └── Google Sheets Log

The critical design decision is that Agent 1 and Agent 2 run in parallel. They receive the same input — a company name and market context — but each has a distinct system prompt and produces a different slice of analysis. Agent 3 only runs after both upstream agents have finished, consuming both outputs to produce an executive synthesis.

This maps closely to the "fan-out / fan-in" pattern you would implement in LangChain or a task queue, but n8n's visual canvas makes the data flow explicit and debuggable without writing orchestration code.

Section 2: The Three Agents

Agent 1 — Market Analyst

System prompt:

You are a senior market research analyst. Given a company name and industry context,
produce a structured market analysis covering:
1. Market overview and definition
2. Total addressable market (TAM) with size and growth rate
3. Key macro trends (3-5 bullet points)
4. Primary customer segments with pain points
5. Regulatory or technology tailwinds/headwinds

Be specific. Use numbers where available. Flag assumptions clearly.
Output valid JSON matching the schema provided.

Output schema:

{
  "market_overview": "string",
  "tam_estimate": "string",
  "growth_rate": "string",
  "key_trends": ["string"],
  "customer_segments": [{ "name": "string", "pain_points": ["string"] }]
}

This agent is good at breadth. It sets the stage: is this a crowded space or a greenfield? Is the market growing or contracting? Downstream agents and the final synthesizer reference these findings.

Agent 2 — Competitor Analyst

System prompt:

You are a competitive intelligence specialist. Given a target company and market,
produce a structured competitor analysis covering:
1. Top 3-5 direct competitors with brief profiles
2. Competitive positioning matrix (price vs. feature depth)
3. Identified gaps in current market offerings
4. Specific strategies for winning against each competitor

Focus on actionable intelligence, not generic descriptions.
Output valid JSON matching the schema provided.

Output schema:

{
  "competitors": [{ "name": "string", "strengths": ["string"], "weaknesses": ["string"] }],
  "positioning_matrix": "string",
  "market_gaps": ["string"],
  "win_strategies": [{ "competitor": "string", "tactics": ["string"] }]
}

Running this in parallel with the Market Analyst cuts total latency roughly in half. On DeepSeek V3, each agent call takes around 4-8 seconds. Sequential execution would stack those delays; parallel execution caps them at the slower of the two.

Agent 3 — Strategy Synthesizer

System prompt:

You are a strategy consultant preparing an executive briefing. You will receive:
- A market analysis (from Market Analyst)
- A competitor analysis (from Competitor Analyst)

Synthesize these into a concise strategic report with:
1. Executive summary (3 sentences max)
2. Top 3 strategic recommendations with rationale
3. Quick wins achievable in 30 days
4. KPIs to track success over 90 days

Cross-reference findings from both inputs. Surface non-obvious connections.
Output valid JSON matching the schema provided.

Agent 3 is where the multi-agent design pays off. A single-agent approach would have to hold both the market context and competitor detail in its reasoning simultaneously, which introduces more hallucination surface area. By letting two specialist agents do the groundwork first, the synthesizer operates on already-structured, validated JSON rather than raw prompts.

Section 3: The Parallel Execution Trick

This is the key insight most n8n tutorials skip over.

When you split workflow execution across two branches (by connecting one node's output to two different downstream nodes), n8n does not automatically wait for both branches to finish before continuing. It will fire each branch and move on. If you naively connect both agent outputs to a single downstream node, you will get two separate executions of that downstream node — one for each branch completing.

The fix is the Merge node, configured like this:

{
  "parameters": {
    "mode": "waitForAll",
    "outputType": "all"
  },
  "type": "n8n-nodes-base.merge",
  "typeVersion": 3
}

With mode: "waitForAll", the Merge node holds execution until all input branches have produced at least one item. With outputType: "all", it passes through every item from every branch as a combined array into the next node.

After the Merge node, a small Code node restructures the data:

// Merge node outputs items from both branches in the items array
const marketAnalysis = items.find(i => i.json.agent === 'market_analyst')?.json;
const competitorAnalysis = items.find(i => i.json.agent === 'competitor_analyst')?.json;

return [{
  json: {
    market: marketAnalysis,
    competitors: competitorAnalysis,
    query: items[0].json.query,
    timestamp: new Date().toISOString()
  }
}];

This gives Agent 3 a clean, merged input object rather than a raw array. The agent sees one structured payload and can reference both analyses by key.

One practical note: tag each agent's output with its identity (agent: 'market_analyst') in the AI Agent node's output mapping. This makes the downstream Code node's find() lookup reliable regardless of which branch finishes first.

Section 4: Cost Analysis

Here is what this pipeline costs to run per query with DeepSeek V3 as the backend model:

Component	Tokens (approx.)	Cost
Agent 1 — Market Analyst	~800 in / ~600 out	$0.0009
Agent 2 — Competitor Analyst	~800 in / ~700 out	$0.0010
Agent 3 — Strategy Synthesizer	~1,800 in / ~900 out	$0.0011
Total per query	~5,600 tokens	~$0.003

At $0.003 per report, you can run 333 research queries for $1.

Compare that to:

Hiring a research analyst: $50-100/hr, 2-4 hours per report = $100-400 per report
Dedicated competitive intelligence platforms (Crayon, Klue, Kompyte): $500-2,000/month
Perplexity Pro or similar AI research tools: $20/month but no workflow integration, no structured output, no Google Sheets logging

The n8n pipeline produces structured JSON that flows directly into downstream automations — Notion databases, Slack digests, email reports, CRM updates. That integration layer is where the real productivity gain lives, not just in the raw AI output.

For teams running competitive intelligence on 10-20 companies per week, this pipeline replaces a meaningful portion of manual analyst time at a cost that rounds to zero.

Putting It Together

The workflow handles a few edge cases worth noting:

Validate Request node: checks that the incoming webhook payload has a non-empty query field and a company field before wasting tokens on a bad request. Returns a 400 with an error message if validation fails.
Google Sheets logging: after the final response is sent, a separate branch logs the query, timestamp, and a summary of the output. This builds a historical record of all research runs without blocking the response.
Error handling: each AI Agent node has a fallback branch that catches timeouts or API errors and returns a structured error payload rather than a raw exception. The Merge node handles partial failures gracefully because the Code node checks for undefined before accessing nested fields.

The entire workflow is 12 nodes. Import time from JSON is under 30 seconds. Adding a new research agent — say, a Patent Analyst or a Pricing Analyst — is a matter of duplicating an existing agent node, updating the system prompt, and adding another input connector to the Merge node.

Get the Workflow

This workflow is part of my 16-template AI automation pack covering research pipelines, lead enrichment, content generation, and Slack/email digests — all built on n8n with DeepSeek or OpenAI as the backend.

Get the importable JSON files at [GUMROAD_LINK].

Full-stack developer specializing in AI automation, MCP servers, and Claude Code integrations. I build production workflows that replace manual research and content tasks with structured, auditable AI pipelines.

Building an AI Voice Agent Pipeline with n8n — Analyze Calls, Score Leads, Alert in Real-Time

KrisYing — Wed, 11 Mar 2026 22:16:10 +0000

Voice AI is having a moment. Upwork reported a +329% year-over-year surge in voice agent project postings in early 2026. But here's what most tutorials miss: the call itself is only half the story. What happens after the call — extracting intent, scoring the lead, alerting your sales team, logging to CRM — that's where the business value actually lives.

This article walks through a production-grade post-call intelligence pipeline built entirely with n8n. No custom infrastructure, no glue code — just a workflow you can import and activate in minutes.

The Architecture

The pipeline connects five stages in a single n8n workflow:

[Vapi / Retell / Synthflow]
        ↓  webhook (call ended event)
[n8n Webhook Node]
        ↓  raw transcript + metadata
[AI Analysis Node — DeepSeek/OpenAI]
        ↓  structured JSON: intent, score, sentiment
[IF Node — leadScore >= 7 AND qualifiedLead = true]
    ↓ YES                        ↓ NO
[Slack Alert]              [Low-priority log]
        ↓
[Google Sheets — CRM Log]

Compatible voice platforms: Vapi, Retell AI, Synthflow, Bland.ai — any platform that sends a webhook on call completion with the transcript in the payload.

The webhook payload typically looks like this (Vapi example):

{
  "type": "call-ended",
  "call": {
    "id": "call_abc123",
    "duration": 187,
    "transcript": "Agent: Hi, thanks for calling Apex Realty...\nCaller: Yes, I'm looking to buy...",
    "phoneNumber": "+14155551234",
    "metadata": {
      "campaign": "google-ads-q1"
    }
  }
}

Section 1: Receiving and Parsing the Call Event

The n8n Webhook node listens at a path like /voice-agent/call-ended. Set it to POST, respond immediately with 200 OK (don't make the voice platform wait), then pass the payload downstream.

A Code node extracts the fields you need before hitting the AI:

const call = $input.item.json.call;
return [{
  json: {
    callId: call.id,
    duration: call.duration,
    transcript: call.transcript,
    phoneNumber: call.phoneNumber,
    campaign: call.metadata?.campaign ?? "unknown"
  }
}];

Section 2: AI Transcript Analysis — The Intelligence Layer

This is where the real work happens. An HTTP Request node (or the native OpenAI node) sends the transcript to your model with a structured extraction prompt:

You are a sales intelligence analyst. Analyze this call transcript and return ONLY valid JSON.

Extract:
- callerIntent: one of [buying, selling, renting, refinancing, pricing_inquiry, scheduling, complaint, general_inquiry]
- sentiment: one of [positive, neutral, negative]
- urgency: one of [immediate, within_month, exploring, unknown]
- leadScore: integer 1-10 (10 = ready to buy/commit now)
- qualifiedLead: boolean (true if they have budget, authority, need, and timeline)
- actionItems: array of strings (what the sales team should do next)
- summary: one-sentence summary of the call

Transcript:
{{transcript}}

The model returns clean JSON like:

{
  "callerIntent": "buying",
  "sentiment": "positive",
  "urgency": "within_month",
  "leadScore": 8,
  "qualifiedLead": true,
  "actionItems": [
    "Send 3-bedroom listings in Maplewood under $650K",
    "Schedule follow-up call for Thursday afternoon"
  ],
  "summary": "Caller is pre-approved for $650K, actively searching, prefers Maplewood area."
}

The 8 callerIntent types were tuned across hundreds of real estate and SaaS sales calls. Getting intent classification right is critical — it determines downstream routing, not just the lead score.

Section 3: Routing Logic — The IF Node

n8n's IF node evaluates two conditions with AND logic:

Condition	Operator	Value
`{{ $json.leadScore }}`	Greater than or equal to	`7`
`{{ $json.qualifiedLead }}`	Equal to	`true`

True branch (hot lead): Triggers the Slack alert immediately.
False branch (cold/warm lead): Writes to Google Sheets for later follow-up without pinging anyone.

The Slack message template:

*Hot Lead Alert* — Score: {{ $json.leadScore }}/10
Phone: {{ $json.phoneNumber }} | Campaign: {{ $json.campaign }}
Intent: {{ $json.callerIntent }} | Urgency: {{ $json.urgency }}
Summary: {{ $json.summary }}
Next steps: {{ $json.actionItems.join(', ') }}

Sales reps get a fully contextualized brief in Slack within seconds of the call ending — no listening to recordings, no manual CRM entry.

Section 4: Why DeepSeek Makes This Viable at Scale

Running AI analysis on every inbound call has a cost problem at OpenAI prices:

Model	Input cost per 1M tokens	10,000 calls/month (~500 tokens avg)
GPT-4o	$5.00	~$25/month
GPT-4 Turbo	$10.00	~$50/month
DeepSeek V3	$0.14	~$0.70/month

For a real estate agency handling 300 calls/day, DeepSeek cuts AI analysis costs from $450/month to under $13/month with comparable extraction quality on structured tasks like this. The prompt above works without modification on any OpenAI-compatible endpoint — just swap the base URL:

Base URL: https://api.deepseek.com/v1
Model: deepseek-chat
API Key: your-deepseek-key

Section 5: Real-World Use Cases

Real estate agencies — Score buyer/seller intent, auto-assign leads to agents by territory, trigger listing alerts to hot buyers within minutes of the call.

SaaS sales teams — Detect trial-to-paid signals, flag churn risk calls for CS intervention, log MEDDIC qualification fields to HubSpot automatically.

Healthcare appointment booking — Extract appointment type, insurance mentioned, urgency level. Route to the correct specialist's calendar without front-desk intervention.

Legal intake — Classify case type (personal injury, family law, criminal), assess case strength signals, prioritize callbacks for high-value case types.

In each scenario the workflow is identical — only the callerIntent taxonomy and routing rules change. That's the composability advantage of building in n8n rather than hard-coding a custom integration.

The Google Sheets CRM Log

Every call — hot or cold — gets logged to a Google Sheets row via the Google Sheets node:

Column	Source
Timestamp	`{{ $now }}`
Call ID	`{{ $json.callId }}`
Phone	`{{ $json.phoneNumber }}`
Duration (s)	`{{ $json.duration }}`
Intent	`{{ $json.callerIntent }}`
Score	`{{ $json.leadScore }}`
Qualified	`{{ $json.qualifiedLead }}`
Sentiment	`{{ $json.sentiment }}`
Urgency	`{{ $json.urgency }}`
Summary	`{{ $json.summary }}`
Campaign	`{{ $json.campaign }}`

This gives you a queryable call intelligence database without touching any backend code. Filter by score, pivot by intent, chart conversion rates by campaign — all in Google Sheets.

Get the Production-Ready Template

Building this from scratch takes a few hours of trial and error — prompt tuning, webhook debugging, IF node condition syntax, Sheets column mapping. I've already done that work.

I've packaged this as a production-ready n8n JSON template you can import and activate in 5 minutes. It includes the full workflow, the tuned AI prompt, Slack message template, and a Google Sheets schema you can copy.

Get it along with 15 other AI automation templates at [GUMROAD_LINK].

The bundle includes templates for lead enrichment, competitor monitoring, support ticket triage, contract summarization, and more — all built with the same n8n + DeepSeek cost-efficient stack.

I build AI automation systems, MCP servers for Claude/Cursor integration, and custom agent pipelines. If you're looking to automate a business workflow or need a production-grade AI integration built fast, find me on Upwork or reach out directly.

Tech stack I work with: n8n, Claude Code, MCP protocol, OpenAI/DeepSeek APIs, Node.js/TypeScript, Python.

📦 Get My Templates

Want these templates ready to use? Check out my complete collection of

25 production-ready n8n automation templates — ready to deploy immediately.

👉 Get the n8n Templates Bundle ($10)

Perfect for automation engineers, consultants, and anyone looking to accelerate their n8n projects with battle-tested workflows.

Multi-Agent AI in n8n: 3 Parallel Agents for Competitive Intelligence

KrisYing — Wed, 11 Mar 2026 22:08:44 +0000

Section 1: The Architecture

Here is the full workflow at a glance:

Webhook Trigger
    └── Validate Request (Code node)
            ├── Agent 1: Market Analyst ──────────┐
            │                                      ├── Merge Node (waitForAll)
            └── Agent 2: Competitor Analyst ───────┘
                                                        └── Code Node: Merge Results
                                                                └── Agent 3: Strategy Synthesizer
                                                                        └── Respond to Webhook
                                                                                └── Google Sheets Log

Section 2: The Three Agents

Agent 1 — Market Analyst

System prompt:

You are a senior market research analyst. Given a company name and industry context,
produce a structured market analysis covering:
1. Market overview and definition
2. Total addressable market (TAM) with size and growth rate
3. Key macro trends (3-5 bullet points)
4. Primary customer segments with pain points
5. Regulatory or technology tailwinds/headwinds

Be specific. Use numbers where available. Flag assumptions clearly.
Output valid JSON matching the schema provided.

Output schema:

{
  "market_overview": "string",
  "tam_estimate": "string",
  "growth_rate": "string",
  "key_trends": ["string"],
  "customer_segments": [{ "name": "string", "pain_points": ["string"] }]
}

This agent is good at breadth. It sets the stage: is this a crowded space or a greenfield? Is the market growing or contracting? Downstream agents and the final synthesizer reference these findings.

Agent 2 — Competitor Analyst

System prompt:

You are a competitive intelligence specialist. Given a target company and market,
produce a structured competitor analysis covering:
1. Top 3-5 direct competitors with brief profiles
2. Competitive positioning matrix (price vs. feature depth)
3. Identified gaps in current market offerings
4. Specific strategies for winning against each competitor

Focus on actionable intelligence, not generic descriptions.
Output valid JSON matching the schema provided.

Output schema:

{
  "competitors": [{ "name": "string", "strengths": ["string"], "weaknesses": ["string"] }],
  "positioning_matrix": "string",
  "market_gaps": ["string"],
  "win_strategies": [{ "competitor": "string", "tactics": ["string"] }]
}

Agent 3 — Strategy Synthesizer

System prompt:

You are a strategy consultant preparing an executive briefing. You will receive:
- A market analysis (from Market Analyst)
- A competitor analysis (from Competitor Analyst)

Synthesize these into a concise strategic report with:
1. Executive summary (3 sentences max)
2. Top 3 strategic recommendations with rationale
3. Quick wins achievable in 30 days
4. KPIs to track success over 90 days

Cross-reference findings from both inputs. Surface non-obvious connections.
Output valid JSON matching the schema provided.

Section 3: The Parallel Execution Trick

This is the key insight most n8n tutorials skip over.

The fix is the Merge node, configured like this:

{
  "parameters": {
    "mode": "waitForAll",
    "outputType": "all"
  },
  "type": "n8n-nodes-base.merge",
  "typeVersion": 3
}

After the Merge node, a small Code node restructures the data:

// Merge node outputs items from both branches in the items array
const marketAnalysis = items.find(i => i.json.agent === 'market_analyst')?.json;
const competitorAnalysis = items.find(i => i.json.agent === 'competitor_analyst')?.json;

return [{
  json: {
    market: marketAnalysis,
    competitors: competitorAnalysis,
    query: items[0].json.query,
    timestamp: new Date().toISOString()
  }
}];

This gives Agent 3 a clean, merged input object rather than a raw array. The agent sees one structured payload and can reference both analyses by key.

Section 4: Cost Analysis

Here is what this pipeline costs to run per query with DeepSeek V3 as the backend model:

Component	Tokens (approx.)	Cost
Agent 1 — Market Analyst	~800 in / ~600 out	$0.0009
Agent 2 — Competitor Analyst	~800 in / ~700 out	$0.0010
Agent 3 — Strategy Synthesizer	~1,800 in / ~900 out	$0.0011
Total per query	~5,600 tokens	~$0.003

At $0.003 per report, you can run 333 research queries for $1.

Compare that to:

Hiring a research analyst: $50-100/hr, 2-4 hours per report = $100-400 per report
Dedicated competitive intelligence platforms (Crayon, Klue, Kompyte): $500-2,000/month
Perplexity Pro or similar AI research tools: $20/month but no workflow integration, no structured output, no Google Sheets logging

For teams running competitive intelligence on 10-20 companies per week, this pipeline replaces a meaningful portion of manual analyst time at a cost that rounds to zero.

Putting It Together

The workflow handles a few edge cases worth noting:

Validate Request node: checks that the incoming webhook payload has a non-empty query field and a company field before wasting tokens on a bad request. Returns a 400 with an error message if validation fails.
Google Sheets logging: after the final response is sent, a separate branch logs the query, timestamp, and a summary of the output. This builds a historical record of all research runs without blocking the response.
Error handling: each AI Agent node has a fallback branch that catches timeouts or API errors and returns a structured error payload rather than a raw exception. The Merge node handles partial failures gracefully because the Code node checks for undefined before accessing nested fields.

Get the Workflow

Get the importable JSON files at [GUMROAD_LINK].

📦 Get My Templates

Want these templates ready to use? Check out my complete collection of

25 production-ready n8n automation templates — ready to deploy immediately.

👉 Get the n8n Templates Bundle ($10)

Perfect for automation engineers, consultants, and anyone looking to accelerate their n8n projects with battle-tested workflows.