Plug AI Into Your Automation — Giving Your Workflow a Brain

OUTCOME — What you'll have afterward

Following this tutorial leaves you with four things.

What gets built

• One agent-action scenario connecting Google Sheets → AI node → Gmail across three nodes
• A reusable prompt containing the three essential blocks: role, instructions, tone
• A flow in which upstream variables are inserted with double curly braces, producing a per-inquiry tailored reply
• (Optional) A structured JSON output that lets you pull out subject, body, and priority separately and branch on them

📖 Term: What is an "agent action"? In Chapter 3-2 we split actions into two classes. A simple action runs by a fixed rule — "when a new row appears, send an alert." Conditions met, action fires, no thought involved. A vending machine. An agent action reads the content and decides what to do. The same trigger produces different behavior depending on the data — a "product damaged" inquiry goes to the urgent lane, a "shipping question" goes to the auto-reply lane. A trained employee. The AI node is what produces that judgment, and in this tutorial you plug one into your scenario with your own hands.

Tutorial metadata

Item	Value
Time	35 min (fast: 25, unhurried: 50)
Level	Intermediate (for those who finished 3-3)
Tools	Make account + one AI API key (Gemini 3 or Claude Sonnet 4.6)
Payment	Make free plan + AI free/low tier is plenty
Prerequisite	Completed the 3-3 Sheets→Slack/Gmail scenario

Why this — the difference 35 minutes makes

Your 3-3 scenario runs but isn't smart. Fifty inquiries, fifty identical alerts. Thirty-five minutes from now, the same fifty produce fifty tailored replies — three urgent ones pinged to the owner, forty-seven shipped to customer inboxes. Your labor stays at zero. Once you've felt "zero effort, judgment delegated," you'll reflexively ask "Can I plug AI here?" for every task. That one question reshapes the next decade.

Where you are now: you've confirmed what this tutorial produces. Next up: prerequisites check before we roll.

---

PREREQUISITES — What you need

Only three things.

Required

• Make account + 3-3 scenario: Sheets Watch New Rows → Slack/Gmail must already run
• One AI API key: Gemini 3 / Claude Sonnet 4.6 / GPT-5.4 — just one. Defaults to Gemini 3 with the others in parallel
• 3–5 test inquiries in Sheets: Name, Email, Type, Content — one each of product, technical, refund, partnership

Not required

• Paid Make plan (free 1,000-op/month is plenty)
• AI paid sub (free tier or one $5 prepay runs the month)
• Programming or JSON skill — everything is below

📖 Term: What is an API key? API = Application Programming Interface — the counter through which programs talk. Gemini 3 and Claude open counters so automation tools like Make can call them. Your API key is the badge you flash at that counter — a long password-like string. In 3-3 you used Gmail OAuth; AI services replace OAuth with an API key. Same purpose, different procedure. Warning: keys are passwords. Never commit to public repos, or someone else spends your money tonight.

Environment check (2 min)

• Logged into Make, 3-3 scenario visible — yes
• AI API key copied into a notepad — yes
• 3–5 test rows in the Google Sheet — yes

Three yeses, you're ready. Any gap — fill it first. Half-prepared guarantees a mid-flow wall.

Where you are now: materials in place. Next — why plugging AI in elevates the whole discipline. Then hands-on.

---

WHY — Why you plug AI into an automation

Not because "AI is trendy." Three specific reasons.

Reason one — traditional automation's limit was "no judgment."

Your 3-3 scenario works but cannot decide. New row → Slack alert, regardless of content. Vending machine: coin in, coffee out. Only useful in domains with no exceptions. Ninety percent of real work has exceptions — urgent/normal, product/technical/refund/partnership, Korean/English. Hand-coded if-else takes a month and still misses cases. One AI node handles the infinity of exceptions with a single paragraph of natural language.

Reason two — an AI node obeys the same rules as any other node.

People assume "AI is special, I'll need to learn it separately." Not true. From Make's perspective an AI node is just another external node, as vanilla as Gmail or Slack. Previous node's output becomes its input, its result becomes the next node's input. The only difference: instead of sending a message, it asks the AI for one. Everything from 3-3 — output→input, variable mapping, connection reuse — applies one-for-one. Almost nothing is new except the prompt.

Angle	Gmail node	Slack node	AI node
Input	to, subject, body	channel, message	prompt (natural-language instruction)
Output	message ID, success flag	message ID	AI response text (or JSON)
Connection method	Google OAuth	Slack OAuth	API key
Upstream variable mapping	double braces {{}}	double braces {{}}	double braces {{}}
Connection reuse	one connection, many nodes	same	same

Two new concepts — prompt and API key. The rest is 3-3 one-for-one.

Reason three — "agent" sounds scary but the actual thing is what you're building.

"AI agent" is everywhere in the news. LangGraph, CrewAI, Claude Skills, OpenAI Assistants — agent frameworks are now mainstream. But the underlying structure is exactly what you're building here: input → AI judges → output. Complex agents are this cell chained with branches and loops. Today you build that cell with your own hands. Next "AI agent project" pitch, you'll be the one who has actually run one.

Where you are now: three reasons are clear. Time for the real thing. Seven steps, 25–35 min.

---

STEPS — The 7-step build

Step 1. Pick an AI service and grab an API key (5 min)

No preference? Start with Gemini 3 — most generous free tier (1,500 req/day, 15 req/min — sufficient for most 2026 workflows) and quality at this tutorial's level is fine.

• Gemini 3: aistudio.google.com → Google sign-in → "Get API key" → "Create API key" → copy
• Claude Sonnet 4.6: console.anthropic.com → sign up → "API Keys" → "Create Key" → copy ($5 prepay needed; Sonnet 4.6 recommended — best speed/quality balance in the Claude lineup)
• GPT-5.4: platform.openai.com → sign up → "API keys" → "Create new secret key" → copy (prepay needed)

Keys look like AIza... (Gemini), sk-ant-... (Claude), sk-... (OpenAI). Copy before closing the tab. Claude and OpenAI show it once only.

📖 Term: What is a "connection"? In 3-3 the Gmail node triggered a "sign in with Google" prompt — that was connection creation, handing Make permission to act for you. Create once, reuse across ten Gmail nodes. AI connections work identically — you paste an API key instead of OAuth. One connection, reusable across every future Gemini/Claude/OpenAI node.

Step 2. Clone the 3-3 scenario and insert the AI node (3 min)

From the Make dashboard, open the 3-3 scenario, click three-dot menu → Clone. Never touch the original. Experiments live in clones.

Rename the clone "3-4 AI Auto-Reply Practice" and open it. Current chain: Google Sheets Watch New Rows → Slack Send Message.

Insert an AI node in front of Slack. Hover the connecting line, a "+" button appears, click it, search "Gemini" (or "Claude", "OpenAI"), select the service, then pick "Create a Completion" / "Generate a Message" / "Generate Response" — exact name varies but the semantic is identical.

Step 3. Create the AI connection (2 min)

First field in the node pane is Connection. Drop down → "Add."

• Connection name: "My Gemini API"
• API Key: paste from Step 1
• Save

Done. Future AI nodes list this connection for one-click reuse, just like Gmail in 3-3.

Step 4. Write the prompt — your AI's job manual (10 min)

This step is the heart of the tutorial. Prompt quality determines 80% of the result.

Find the "Prompt" or "Messages" field in the AI node settings. A good prompt always has three blocks: role + specific instructions + tone & manner.

Copy the template below. Leave the placeholders blank for now — Step 5 fills them in.

You are the customer support specialist for a tech startup called "Innovation."

Customer info:
- Name: [customer name goes here]
- Email: [email goes here]

Inquiry info:
- Inquiry type: [inquiry type goes here]
- Inquiry content: [inquiry content goes here]

Follow these instructions when writing the reply:
1. Greet the customer by name, warmly.
2. Summarize the inquiry in one sentence to show you understood it.
3. Give a concrete, step-by-step solution matched to the inquiry type.
   - Product inquiry: include key features and pricing
   - Technical support: give step-by-step troubleshooting
   - Refund/exchange: explain the policy and timeline
   - Partnership: include a contact and propose a meeting
4. Close by inviting them to reply if they need more help.

Style:
- Friendly and professional tone
- 3–4 paragraphs
- Explain any technical terms plainly

Role, specific instructions, tone — all explicit. Three blocks = your AI-as-new-hire's job manual.

📖 Term: Prompt-as-a-node In classic automation the atomic unit was "when data arrives, run this code." In AI-native automation it becomes "when data arrives, ask the AI with this prompt." The prompt itself is a workflow step — hence "prompt as a node." This is what opens automation to people who don't code: you author in natural language instead of a programming language. The single biggest shift in the automation world — and now MCP (Model Context Protocol) is standardizing how tools, APIs, and databases connect to AI nodes, making the whole system even more composable.

Step 5. Variable mapping — plug upstream data in (5 min)

Your prompt has four placeholders. Wire Google Sheets node outputs into them as variables.

Works exactly like the Slack step in 3-3: cursor into the placeholder, expand the Google Sheets entry in the right panel, click Name/Email/Type/Content. Double-brace tokens like {{name}} drop in automatically.

Finished prompt:

You are the customer support specialist for a tech startup called "Innovation."

Customer info:
- Name: {{name}}
- Email: {{email}}

Inquiry info:
- Inquiry type: {{inquiry_type}}
- Inquiry content: {{inquiry_content}}

Follow these instructions when writing the reply:
(rest unchanged)

When the scenario runs, {{name}} becomes "John Kim" on one row, "Jane Lee" on the next. One prompt, as many tailored replies as customers.

Author once; every inquiry gets a custom answer at runtime. Fifty rows, fifty replies. Effort stays at zero.

Step 6. Wire the AI output into the Gmail node (5 min)

The AI node returns text. Pipe it into the next node to complete the agent action.

Current chain: Sheets → AI → Slack. Slack is fine internally, but the real win is a customer-facing auto-reply. Swap Slack for Gmail Send Email, or keep Slack and add Gmail alongside.

Gmail settings:

• To: {{email}} from Sheets
• Subject: e.g., [Innovation] Your {{inquiry_type}} response
• Content (Body): the AI output variable ("text", "message", or choices[0].message.content by provider)

Key: AI output becomes Gmail input — the same "output→input" rule from 3-3.

Step 7. Run once and debug (5 min)

Click "Run once" bottom-left. New row detected, AI generates, Gmail ships.

Check the test inbox. A tailored reply. Congrats — your first agent action is live.

Add 2–3 more rows and rerun. Different reply per row is when it clicks.

Errors flag red at the offending node. Click, open "Output", inspect data. Most issues — TROUBLE below.

Where you are now: an agent-action scenario is running. Next — verification checkpoint.

---

VERIFICATION — What counts as done

Five yeses and you're complete.

1. [ ] Three nodes chained: Google Sheets → AI → Gmail, lines green
2. [ ] Prompt has role + instructions + tone + 4+ {{variables}}
3. [ ] Run once completed green at every node — no red marks
4. [ ] Tailored reply landed at test email. Body reflects the actual row. You read "Hello, John Kim," not "Hello, {{name}}"
5. [ ] 2–3 more rows produced different replies. Refund → policy + timeline; technical → step-by-step

Any "no"? Common failures: item 2 (prompt too short/vague) and item 4 (variable unfilled, {{name}} passes through literally). Return to Steps 4–5.

---

VARIATIONS — Shapes this can take

Variation 1 — Structured output via JSON

So far the AI returns one blob. Make it return labeled fields and downstream branches get sharper. In 2026, Gemini 3, Claude Sonnet 4.6, and GPT-5.4 all support structured JSON output reliably — enable "JSON mode" or "Response format: JSON object" in node settings alongside your prompt instruction.

Append to your prompt:

Return the result in the following JSON format. Output pure JSON text only — no markdown code fences.

{
  "subject": "email subject",
  "body": "email body",
  "priority": "urgent or normal",
  "category": "product / technical / refund / partnership"
}

Drop a Parse JSON node after the AI node — four fields come out separately. Wire {{subject}} to Gmail Subject, {{body}} to Body. Add a Router that fires an extra Slack alert only when {{priority}} equals "urgent."

📖 Term: Structured output Asking the AI for JSON so the next program reads it as structured data is called structured output. Plain text works for humans but is ambiguous for a branch asking "urgent?" JSON puts the priority field right there, ready to route on. All major models now expose a native structured output or "JSON mode" toggle — use both the prompt instruction and the node setting for maximum reliability.

Variation 2 — Human-in-the-loop checkpoint

Money-touching decisions like refund issuance shouldn't ship automatically. Insert a Slack Create a Message after the AI node — "AI drafted this; ship it?" — and fire Gmail only on an approval emoji. Make supports this via a Webhook pattern (later tutorial). Principle: anything touching money, trust, or someone's name gets a human review.

Variation 3 — Classification only

Tell the AI "answer in one word — urgent, normal, or spam" and you have a classifier. Route through a three-way branch: urgent → owner, normal → auto-reply, spam → delete. Faster, cheaper, more reliable than generation. In production the judging use case is more common than writing.

Variation 4 — Multilingual

Add one line: "If the inquiry is English, answer English; if Korean, answer Korean." One form, five languages, zero delay.

---

TROUBLE — Common snags

❓ "Invalid API Key"

You probably pasted the key with leading/trailing spaces. Edit the connection, clear the field, paste cleanly. Still failing? Rotate the key from the provider console and rebuild. Claude and OpenAI won't work without a prepaid balance — visit the billing page and prepay ~$5.

❓ {{name}} shows up literally (variable didn't bind)

You cannot type {{name}} as text. You must click the field in the variable panel on the right — that drops in a real binding, rendered as a lavender chip. Plain text without the chip is just a string and passes through unchanged.

❓ "Rate limit exceeded" or "Quota exceeded"

You hit the free-tier quota. By 2026, most APIs have raised rate limits roughly 10× compared to 2025, but free tiers still have ceilings. Gemini 3 free caps at ~15 req/min and 1,500/day; Claude/OpenAI errors usually mean empty credits. Wait an hour or prepay $5–10. During testing, don't mash Run once.

❓ AI reply too long or too short

Your tone-&-manner block probably skipped length. Write it in numbers: "3–4 paragraphs, under 500 characters." "Reasonable length" means nothing to an LLM; exact counts work.

❓ Asked for JSON, got markdown code fences

Strengthen the prompt: "Output pure JSON text only — no markdown code fences." If it still leaks, enable "JSON mode" / "Response format: JSON" in node options. That's the rock-solid fix. Mixed fences break Parse JSON and freeze the scenario.

❓ Scenario succeeded but no email

Check spam. The first automated Gmail from a new Make connection often lands there. Mark "Not spam," add to contacts, future mail delivers normally.

❓ Same Google Sheets row processed multiple times

Watch New Rows "Limit" too high, or Make isn't remembering what it saw across repeated Run once clicks. Use "Reset trigger," or actually add a fresh row before clicking Run once.

---

NEXT — What comes after

Thirty-five minutes ago your automation was a vending machine. Now it's a trained employee. Not a skill gap — a worldview gap. From here on, every task triggers a reflex: "Can I plug an AI into this judgment step?" That one question compounds over the next decade.

What you built is one neuron of an AI agent. When the news screams "autonomous agents," "multi-agent systems," and "LangGraph pipelines," you won't flinch. Complex agents are this cell stacked, branched, looped. You've already touched the cell.

This is episode 3-4 of the SPIN series. The arc:

1. Scenario fundamentals — two-node automation (3-3, done)
2. Plugging in the AI node ✓ (today, done)
3. Workshop — end-to-end build (coming)
4. Agent expansion — Router, Webhook, human-in-the-loop (coming)

Best way to cement this: over the next week, find one more spot and plug an AI node in. Email triage, report summaries, Slack translation, document extraction — anything. One thing your hands know beats ten books. Leave today's scenario open. Walk in tomorrow, see it shipped three replies overnight, and you won't be going back.

당신은 테크 스타트업 '이노베이션'의 고객 지원 전문가입니다.

고객 정보:
- 이름: [고객명이 들어갈 자리]
- 이메일: [이메일이 들어갈 자리]

문의 정보:
- 문의 유형: [문의유형이 들어갈 자리]
- 문의 내용: [문의내용이 들어갈 자리]

다음 지침에 따라 답변을 작성하세요:
1. 고객 이름을 부르며 따뜻하게 인사합니다.
2. 문의 내용을 한 문장으로 요약해 이해했음을 보여줍니다.
3. 문의 유형에 맞는 구체적 해결책을 단계별로 제시합니다.
   - 제품 문의: 주요 기능과 가격 정보 포함
   - 기술 지원: 단계별 해결 방법
   - 환불/교환: 정책과 처리 기간 안내
   - 파트너십: 담당자 연락처와 미팅 제안
4. 추가 도움이 필요하면 연락 달라는 말로 마무리합니다.

답변 스타일:
- 친절하고 전문적인 어조
- 3~4개 단락
- 전문 용어는 쉽게 풀어서 설명

당신은 테크 스타트업 '이노베이션'의 고객 지원 전문가입니다.

고객 정보:
- 이름: {{고객명}}
- 이메일: {{이메일}}

문의 정보:
- 문의 유형: {{문의유형}}
- 문의 내용: {{문의내용}}

다음 지침에 따라 답변을 작성하세요:
(이하 동일)

결과를 다음 JSON 형식으로 출력하세요. 마크다운 코드블록 없이 순수 JSON 텍스트만 출력하세요.

{
  "subject": "이메일 제목",
  "body": "이메일 본문",
  "priority": "긴급 또는 일반",
  "category": "제품 / 기술 / 환불 / 파트너십 중 하나"
}