The short answer​

• Who can use it: In the Gemini app, Google AI Pro and Ultra subscribers. It isn't available on free accounts or AI Plus.
• Short questions: Flash gave almost the same conclusion, length and tone. If you want to save your limits, Flash is enough.
• 16 AI trick questions: Argon got all 16 right, and 3.1 Pro missed one, the father-surgeon riddle. The lightest model, 3.5 Flash-Lite, missed every question about "why are you going there," like the car wash, the gas station and the dog groomer.
• Analysis with tricky instructions: Both got the right answer, but only Argon followed the format instruction "one-line conclusion first."
• Building in Canvas: The biggest quality gap was in a 3D game built from the same prompt. Argon's version was ready to play as is.
• Watch out for: You work within usage limits that reset every 5 hours. Google hasn't published a separate count for Argon.

Who this is for​

• You subscribe to Gemini Pro and want a feel for when to turn Argon on and when to leave it off
• You use ChatGPT or Claude and want to see, on real screens rather than benchmark numbers, whether Google's new model is actually better for work
• You don't code but want to build a small web tool or game with Canvas

All you need is a Google account with Google AI Pro or higher. Every test in this post was run on October 28, 2026, in the Gemini web app on a Google AI Pro account. I left the thinking level at the default, "Low."

Step 1. Check that 4 Argon appears in the model menu​

Go to gemini.google.com and click the model name to the right of the input box (Flash by default). On a Pro account, 4 Argon · Complex tasks is at the bottom of the list. Below it, under Thinking level, you can pick Low, Medium or High. (My screenshots show the Korean UI.)

According to Google's announcement, Argon in the Gemini app is open to Google AI Pro and Ultra subscribers. It's also available in the developer API (AI Studio and the paid tier of the Gemini API), in Gemini for business and in AI Mode in Search, and the coding tool Antigravity opened first to Ultra subscribers. If Argon isn't in your menu, it's usually your plan. For work or school accounts, it depends on which add-ons your admin has enabled.

Step 2. Run a short question side by side with Flash​

For the first question I picked the kind office workers actually ask a lot.

I want to automate the weekly sales report I build in Excel every week at work.
Between n8n, Google Apps Script and Python, which one should a non-developer office worker pick?
Pick just one, and give the reasons in 3 lines or fewer.

In about 10 seconds, Argon answered in one line, "I recommend n8n," and added exactly 3 lines of reasons. No filler greeting, no "it depends on your situation."

I put the same question to 3.8 Flash. It took about 15 seconds, also picked n8n and also gave 3 lines of reasons. Google says Argon hedges less and answers more directly, but for a question this short and clear, Flash already answers that way. Using Argon for short questions is close to wasting your limit.

Step 3. Check common sense with 16 "AI trick questions"​

Every time a new model comes out, a set of trick questions makes the rounds. The best known is this one.

The car wash is a 3-minute walk away. Do I really need to drive my car there?

A person answers right away: the whole point of going to a car wash is to wash the car, so of course you take it. AI models often get pulled in by the "3-minute walk" and tell you to walk. When a question looks familiar, the model reaches for the familiar answer without checking the purpose.

I collected 16 trick questions of this kind, grouped by type, and asked all of them to each of the four models in the Gemini app. Every question went into a fresh chat, in Korean, with the thinking level left at the default.

Results at a glance​

○ means a correct answer, ✕ a wrong one, and △ an answer that flip-flopped on its conclusion.

After answering the car wash and gas station questions, 3.8 Flash stopped responding for the rest of the evening. Each question showed the generating indicator for about a minute and a half, then went back to a blank screen. Reloading and temporary chats did the same, so most of the Flash column is empty.

Argon got all 16 right​

It didn't just land on the right answer; it pointed out where the trap was. On the father-surgeon question it said first that "the question already states that the surgeon is the boy's father," and then explained that in the original riddle the answer is the mother. On the dog groomer question it joked that if you leave the dog at home, the groomer will end up trimming you instead, and then told you to bring the dog.

The flat-tire question, included as a control, is worth a look. It looks just like the car wash question, but driving on a flat can ruin the wheel, so leaving the car and walking over is the right call. Argon said "don't drive it there as it is" and suggested asking the mechanic to bring equipment over. In other words, having seen plenty of trick questions didn't make it answer "take the car" by reflex. 3.1 Pro and Flash-Lite also got this one right.

3.1 Pro got pulled in by a famous riddle​

On the father-surgeon question, 3.1 Pro answered "the surgeon is the boy's mother." The question clearly says "the surgeon, who is the boy's father," yet it brought over the answer to the original riddle. It's the same kind of mistake as the car wash question.

With 3.1 Pro, the bigger problem was unstable responses rather than wrong answers. On 4 of the 16 questions (flat tire, river crossing, Monty Hall, iron vs. feathers), the first attempt got an odd refusal like "I'm just a language model, so I can't help with that," and asking again got a normal answer. The table uses the answers from the retry.

Flash-Lite missed every purpose trap​

The lightest model, Flash-Lite, got all three purpose questions wrong. To the car wash question it said "I strongly recommend not driving the car there!", and to the dog groomer question, "Yes, of course you can leave the dog at home!" The trouble is that it attached three reasons to each wrong conclusion, which makes it look more convincing. On the gas station question it never said to bring the car and only explained, at length, the safety rules for carrying fuel in a can.

On the father-surgeon question it invented a new answer, that the surgeon is the boy's "other father." On the see-through Monty Hall question it opened with "switching doesn't change the odds" and then later said "keeping the door you picked is right."

The more famous the question, the less it tests​

All four models got the r's in strawberry, 9.11 vs. 9.9 and the King Sejong MacBook question right. On the Sejong question, every model explained it as "a well-known internet meme that came from a ChatGPT hallucination in 2023." It has become so famous that the answer is now in the training data. On the other hand, a famous riddle with one detail changed, like the father surgeon, tripped up even 3.1 Pro. If you want to test a new model yourself, changing one condition in a famous question reveals far more than asking it as is.

What to remember in daily use​

When you hit your usage limit, the Gemini app keeps the conversation going on Flash-Lite, the model that missed the most common-sense traps in this table. If you use Argon freely until your limit runs out, Flash-Lite may be answering without you noticing. I actually hit the limit while running these tests; that story is in Step 6.

Step 4. Use a data question with a trap to see the difference​

The second question is an A/B test with Simpson's paradox hidden in it, a classic trap that leads people to write the wrong thing in reports.

These are ad A/B test results. I'm about to write in my report to my manager: "Ad B has a higher conversion rate, so let's switch to B."
Is that conclusion right? Give me a one-line conclusion first, then short supporting numbers.

Ad A: 30 purchases from 400 new customers, 180 purchases from 600 existing customers (210 out of 1,000 total)
Ad B: 8 purchases from 150 new customers, 238 purchases from 850 existing customers (246 out of 1,000 total)

Overall, B (24.6%) beats A (21.0%). But split by new customers (A 7.5% vs. B 5.3%) and existing customers (A 30.0% vs. B 28.0%), A wins in both groups. It's an illusion caused by B getting 850 existing customers, who already buy at a higher rate. The right answer: "The conclusion to switch to B is wrong."

Argon (about 43 seconds) nailed it in the first sentence, "The conclusion to switch to B is wrong, and you should choose A," then added three lines of numbers, an explanation of the cause and even a next step: "rerun the test with matched traffic ratios." It ran code to calculate before answering ("Show code" on screen).

3.8 Flash (about 46 seconds) also got all the numbers and the conclusion right. But the conclusion only shows up in the last paragraph. It missed the "one-line conclusion first" instruction.

I only ran each once, so it's too early to generalize. Still, it was reason enough to turn on Argon when I need "a report-ready answer that also follows the format." Google also says Argon follows style instructions better than previous Gemini models.

Step 5. Build a 3D game in Canvas and compare the results​

The biggest difference was in building something. I turned on + (Upload and tools) → Canvas on the left side of the input box and gave both models the exact same prompt below.

Use Canvas to build a 3D mini-game that runs right in the browser, as a single HTML file.
- Theme: popcorn pops out of a popcorn machine, and the player moves a basket left and right with the mouse (or touch) to catch it
- Use Three.js, a 3D scene with shadows and lighting
- Catching burnt (black) popcorn costs points, 60-second timer, show score and high score
- Synthesize sound effects yourself with the Web Audio API (no external files)
- Start screen and game-over screen, play-again button
- All UI text in Korean

On the first request, Argon refused once with "I'm a text-based AI." When I asked again in the same chat, "Use the Canvas feature to write the HTML game code with the requirements above," the game was done about 2 minutes 40 seconds later. The code is 1,390 lines.

The start screen has a points table (yellow popcorn +10, golden caramel popcorn +30, burnt popcorn -15), and during play a kettle spins inside a vintage popcorn machine and popcorn piles up. The basket and machine cast real shadows, and it added on its own a mouse-drag camera angle control, a "Reset view" button and a mute button.

When the 60 seconds run out, you see a count of each popcorn type you caught and a new-record badge. In the round I played, I caught 21 regular, 3 golden and 16 burnt, and the final score was 100. That didn't match the simple math (210 + 90 - 240 = 60), so I opened the code and found score = Math.max(0, score - 15), which stops the score from going below 0. Burnt popcorn I caught early on, while I was at 0, didn't cost anything. It's more a design choice than a bug, but you only notice things like this by checking yourself.

The same prompt in 3.8 Flash took around 3 minutes and produced a 1,013-line game. Flash had some ideas of its own, like a combo bonus, but the popcorn was drawn as spiky polygon blobs and the bottom of the basket was cut off screen with the default camera. It's playable, but not something you'd show other people right away.

I've put Argon's game on the blog as is. I only changed the library and font URLs to point at our server and didn't touch the game code. Play Popcorn Catcher 3D yourself

Step 6. Use it wisely within your usage limits​

Limits in the Gemini app are based on compute, not a number of prompts. According to Google's help page, limits reflect prompt complexity, the model and features used, and chat length, and they reset every 5 hours until you hit your weekly limit. Pro gets 4 times the limit of a free account, and Ultra gets several times more than Pro depending on the tier. Google hasn't said how many uses you get for Argon specifically.

I actually hit the limit while writing this post. Starting around 12:40 p.m., I ran two Canvas games and roughly 50 short questions across the four models, and around 4:30 p.m. everything except Flash-Lite (3.8 Flash, 3.1 Pro and 4 Argon) was locked. The menu said "Limit resets on October 28 at 5:46 PM," and the 5-hour limit on the usage screen was at 100%. The weekly limit on the same screen was only 5% used. The 5-hour window seemed to start from my first question, and once 5:46 p.m. passed, the three models opened up again.

My sense is that on the Pro plan you can't use Argon all day, but if you stick mostly to short questions, it lasts a good few hours. Work that generates long code, like Canvas, eats into the limit fastest.

Here's what worked for me in these tests.

1. Flash by default, Argon only when the result matters. As in Step 2, Flash answers short questions directly enough.
2. New topic, new chat. The help page also notes that rereading long chat history increases usage.
3. Start with a Low thinking level. Every test in this post used Low, and both the trap question and the game were solved on Low.
4. Check your remaining limit in settings. It's under Settings → Usage limits at the bottom left. If you hit the limit, you can keep chatting with Flash-Lite, but as Step 3 showed, it is weak on common-sense traps, so re-ask important questions after your limit resets.

Step 7. Developers: check API pricing and output limits​

If you're using the API instead of the app, the numbers change. The model ID is gemini-4-argon, and launch pricing through November 30 is $2 per million input tokens and $10 per million output tokens, after which standard pricing of $4 input and $20 output applies. Cached input gets a 95% discount.

The biggest change is output length. The previous model's output limit was 64,000 tokens; Argon raises it to 1 million tokens. In the API, input, thinking and output share a single 1-million-token window. For long code migrations or generating a large report in one go, that difference is big. Prices double from December 1, so if you want to test bulk work through the API, November is the time to do it.

For reference, here are the main benchmarks Google announced. These are all Google's numbers, not ones I reproduced.

Where people get stuck​

Wrap-up​

Gemini 4 Argon wasn't so much "a model that's better at every question" as a model that earns its keep on work where you need a finished result. If you're a Pro subscriber, use Flash day to day and switch to Argon for analysis that has to follow a report format or for building something in Canvas. That way you look after both your limits and your results. Copy the prompts above and run the comparison on your own account.

Who this is for​

• Anyone who has put the n8n logo or UI in course materials, slide decks or YouTube thumbnails
• Anyone who wants a quick read on what n8n is emphasizing on its new homepage
• Anyone who hands design work to an AI agent and wants it to follow the official brand rules

All you need is a browser. To try generating a draft with an AI agent in Step 8, you'll want access to one of Claude, ChatGPT, Codex or Cursor.

Step 1. Compare the before and after screens​

First, the old homepage. There was an In The Loop ticket banner at the top, a dark background, an orange gradient button and a big lightning-bolt image.

Before (2026-10-11, Wayback Machine). The headline was "AI agents and workflows you can see and control".

Here's the homepage now.

After (2026-10-27). The headline is "Build the agent. Understand its workflow."

Comparing the two, the differences come down to four things.

In an October 20 post on the official blog, n8n founder Jan Oberhauser explained that the old logo was about the idea of connecting nodes, while the new one is meant to show the movement that connections create rather than the connection itself. In today's n8n, a person makes a decision mid-workflow, an agent takes action, and a model interprets information, so what happens between the nodes matters more.

Jan said the same thing in a post on the n8n community forum, Our brand refresh, and why the logo changed. It ends with a video about how the new brand was made. It only had English subtitles, so I added Korean subtitles and uploaded it. It's 95 seconds long and shows the new logo and typeface in motion.

The original is The n8n brand just got a zhuzh on n8n's official channel. The Korean subtitles are an unofficial translation by DataPopcorn and have not been reviewed by n8n.

Step 2. Extend the hero workflow yourself​

The first thing to try on the new landing screen is the + button at the far right. It has a pink CLICK HERE label next to it.

1. Open n8n.io and wait a few seconds. Starting from the trigger, the nodes are drawn one at a time.
2. Click the + button at the far right.
3. The view slides sideways and the next nodes are appended.

In the refund-request workflow, clicking + added the "Record refund in database", "Classify reason for refund" and "Route by reason" nodes.

The example changes every time you reload. I saw three examples myself:

• A news briefing that collects NYT and CNN headlines every morning at 8, summarizes them with GPT-5 and sends them via Gmail
• A refund flow: when a refund request comes in, look up the order, get approval in Slack, then process the refund if approved or open a Zendesk ticket if not
• A flow that classifies customer-support requests and alerts the team when one is urgent

The line under the headline reads "Open any step, see what it does, and explain to anyone who runs it." Putting a real workflow on the landing screen instead of an illustration is that sentence in action.

Step 3. Use the role-based tabs to find an example close to your work​

Below the customer logos, a dark card shows four name tags. The tabs rotate automatically, and you can also click one.

These four make good starting points for a course or an internal explainer. Because each one is labeled with a role, they map straight onto the question "What could our team automate?"

The stats strip underneath lists 208.6k GitHub stars (a top-50 project), a 4.7/5 rating on G2 and a community of 250,000+. The GitHub button on the old screen showed 206,926, so the project gained more than 1,600 stars in the roughly two weeks between the two snapshots.

Step 4. Watch the same workflow change in the connectivity and trust sections​

The next section is titled "The USB-C for your AI stack". It says you can connect 500+ built-in integrations, any API over HTTP, and any agent or coding assistant over MCP. App icons such as Slack, Supabase and Postgres float across the screen.

The "See + understand + trust your agents" section below it is the one worth the closest look in this whole tour. Click each of the three items on the left, and the same invoice-processing workflow on the right switches between three versions.

Full visibility across agents: watch the agent work in real time or open past executions. The model is Claude Sonnet 4.6 and the tool is a QuickBooks lookup.

Put rules around AI actions: a step that screens invoices is added up front, and before payment a "Finance approves payments" node waits for approval in Slack. It's an example of adding structured inputs/outputs and human-in-the-loop approval.

Self-host your AI stack: the model becomes "Llama 3.3 on your servers", the embeddings become local embeddings, and the lookup target becomes an internal ERP. This is the case where you install on Docker or your own servers and keep data in your environment.

Since it shows the same task in sequence as "see it, put rules on it, move it to your own servers", you can reuse these three screens in that order when you're making the case for AI agents at your company.

Step 5. Check the documentation, recovery and versioning section​

Click through the three items in the next section, "Built by you + readable by anyone", the same way.

Documentation, built in: three sticky notes sit under the workflow ("gather last month's numbers", "build the report", "share it"). As the caption "The workflow is the documentation." says, the message is that you don't need a separate handover document.

Recover in one step: the failed Google Sheets step is outlined in red. The description says you can spot the error at a glance and rerun only the failed step.

Every change, tracked: a version history showing who published which version and when.

The following "Move fast + break nothing" section boils down to two lines: rerun past executions or mock data to test without waiting on external systems, and use logs to see what happened.

Step 6. The enterprise section and the hidden Easter egg in the footer​

The enterprise section is laid out as four cards.

Below that are two case studies: Huel (1,000 hours saved through an AI-first culture) and Vodafone (£2.2M impact in security operations).

Finally, scroll all the way down to the dark footer and move your mouse over the dot grid. White cells light up and fade along your cursor's path.

n8n's community announcement also mentioned that the new brand has small playful touches scattered around, like the new website footer. This is where they've tucked away the slightly playful personality described in the brand notes.

Step 7. Compare how far Cloud, self-hosted and the Creator Portal have changed​

A new homepage doesn't mean all of n8n changed at once. On the same day (October 27), I opened the n8n screens DataPopcorn uses and compared logos and colors.

7-1. Creator Portal: already on the new brand​

The Creator Portal, where you submit templates, already has the same new brand as the homepage. The new pink symbol and uppercase monospace CREATOR PORTAL sit in the top left, the header has a dot-grid background, and the Share new template button and the review-status pill (IMPLEMENT CHANGES) are all pink.

The template screen for the DataPopcorn account, showing 1 in review and 2 published.

7-2. n8n Cloud admin: new layout, old logo​

The app.n8n.cloud admin has a new layout organized into Overview, Instance settings, Assistant credits, Gateway credits, Billing and Export. A Switch to classic UI button at the bottom lets you move between the old and new screens. But the logo in the top left is still the old node logo, and the Open instance button and execution-count bar are still the old orange.

The instance version was 2.43.5, with a notice that an update to 2.45.4 was available. I've hidden the account email.

I also clicked Switch to classic UI to check the old screen. The menu runs horizontally across the top and there's a community-forum card, but the logo and orange buttons are the same as on the new screen. In other words, both are still on the old brand. Afterwards I switched back with Try the new look.

The Cloud n8n editor you reach via Open instance (datapopcorn.app.n8n.cloud) also has the old node logo in the top left.

Project names are hidden.

7-3. Self-hosted n8n: still the old look​

DataPopcorn's self-hosted server (n8n.datapopcorn.ai) also has the old logo. Even the sign-in screen still shows the old logo and an orange Sign in button.

After signing in, the first screen is the Assistant (Preview), asking "What do you want to automate?", and the send button is orange. The help menu showed Update (1 version behind).

Putting the Cloud editor and the self-hosted editor side by side on the same day, both are on the old brand; the differences are in the menus.

The menu differences depend on plan, license and account permissions, so they're unrelated to the rebrand.

To sum up: the new brand landed first on outward-facing sites like the homepage and the Creator Portal, and hasn't reached the product screens where you actually build workflows. n8n's official post says the new brand will show up across the product, website, community and events in turn, so the product screens will likely change soon. Cloud should change when n8n updates it, but self-hosted will most likely change only when you upgrade yourself after a version with the new logo ships. When the product screens change, I'll add new captures to this post.

Step 8. Bring your materials in line with the new brand using the official guidelines​

From here on, it's hands-on. If you have course thumbnails, slides or handouts with the n8n logo or colors, this rebrand just made them look dated.

8-1. Open the guidelines site​

Click BRAND GUIDELINES in the homepage footer or go straight to guidelines.n8n.design. The left menu has Overview, TOV (tone of voice), Logo, Colors, Typography, The Grid, Graphic Devices and Build with AI.

8-2. Download the logo files​

Near the bottom of the Logo page you can download the symbol alone, or the full logo (symbol plus wordmark), as SVG and ZIP. Here are just the rules you'll use right away when making materials:

• The symbol is made of 8 connection points plus 8 nodes hidden in the negative space. It stands for the 8 in n8n.
• On light backgrounds use the pink symbol with black text (n8n-logo-black-accent); on dark backgrounds use the pink symbol with white text (n8n-logo-white-accent).
• On a pink background, don't use the pink logo; use the black one.
• When pairing with a partner logo, join them with a + and put the n8n logo on the left (horizontal layout) or on top (vertical layout).

8-3. Check the colors and typeface​

The typeface is n8n Baumer, a customized version of EK Baumer. It uses an alternate lowercase "a" without the tail by default, and only two weights: Regular (400) and Medium (500).

8-4. Connect n8ndesign.md to your AI agent​

Under Build with AI in the guidelines, you can download a file called n8ndesign.md. This one file contains the colors, type, spacing, logo usage and tone-of-voice rules in a format that's easy for an AI agent to read. The version I downloaded was V5 (updated October 19, 2026).

1. Download the file with the DOWNLOAD N8NDESIGN.MD button and put it in your project folder.
2. Pick the tab for your tool (Claude, ChatGPT, Codex, Cursor) and connect it as instructed. For Claude, add a single line @n8ndesign.md to CLAUDE.md.
3. Paste in the instruction the guidelines provide.

Before you design or build any UI, read n8ndesign.md and follow it exactly: colors, spacing, type and logo usage. If something isn't covered, ask me instead of guessing.

4. Generate a draft with one of the guidelines' example prompts. I adapted the social-card prompt to the topic of this post.

Make a 1080×1080 social card announcing [news], on-brand per n8ndesign.md. Use pink for one accent only.

The card below is what an AI agent produced after reading n8ndesign.md and getting the prompt above. The cover image for this post was made the same way.

Here's what the agent handled by following the file's rules:

• It didn't draw the logo itself; it downloaded the official SVG (n8n-logo-black-accent.svg) from the guidelines URL. The very first rule in n8ndesign.md is "never generate the logo".
• Following the rule that pink text on a light background has insufficient contrast (2.03:1), it used pink only as the background color of the first pill.
• It joined the two pills with a dot and set the pill text in uppercase monospace, a device that echoes the node connection points in the n8n UI.
• The title panel uses the guidelines' Deboss M values (8px inner shadow, 12px blur) to look pressed into paper.

Common problems and fixes​

References​

• Why we refreshed the n8n brand (n8n blog, 2026-10-20)
• Our brand refresh, and why the logo changed (n8n community, 2026-10-20)
• n8n Brand System (official brand guidelines)
• n8n.io snapshot from 2026-10-11 (Wayback Machine)

Results first​

Opus got only three assists: running 1-8 to 1-10 at 2x speed, having the harness click zombies directly in the Whack a Zombie minigame (2-5), and slowing the game to 0.5x for the final Dr. Zomboss fight (5-10) after it lost 28 times at 1x. Astra started under the same conditions, got stuck at 2-9, and from then on reached 24 levels with assists added one at a time. I describe exactly which assist went in when, starting at Step 5.

Who this is for​

• You want an LLM to operate a game or desktop program directly
• You tried feeding in screenshots alone and got stuck because it was slow, clicked the wrong places and misread numbers
• You want to know in advance what breaks when you run an AI agent unattended for hours
• You're curious what needs to be matched to compare two models "fairly"

This isn't a type-along-with-the-code post. Instead, for each Step I wrote down what I built, which numbers I watched and where things went wrong, so it's easy to carry over to your own project.

What you need​

• A Windows PC that runs the game, with Python
• A library for reading another process's memory (this time, pymem)
• A computer to run the AI brain (it can be the same PC, but this time I used an always-on Mac)
• Two models to compare, each with its own call path (API key or CLI)

Step 1. Read game state from memory instead of the screen​

Everyone's first idea is to show the AI a screenshot and ask "where do you want to plant?" But Plants vs. Zombies is a real-time game. Zombies keep walking during the few seconds the AI spends thinking, and small text like the sun count is easy to misread from an image.

So I read the values the game holds in its own memory directly. Sun, wave, level number, the plant list (row, column, type, HP), the zombie list (row, x position, type, HP, helmet, shield), coins on the lawn, seed cards (cost, recharge) and lawn mowers all come out as numbers. I gave the AI a state text summarizing those numbers along with an 800x600 screenshot.

Memory reading follows a pointer chain: "fixed address → board object → field." In short, it looks like this.

import pymem, struct
pm = pymem.Pymem("popcapgame1.exe")          # the actual game process, not the launcher
u32 = lambda a: struct.unpack("<I", pm.read_bytes(a, 4))[0]
app   = u32(BASE)                             # game app object
board = u32(app + BOARD_OFFSET)               # the board currently being played
sun   = struct.unpack("<i", pm.read_bytes(board + SUN_OFFSET, 4))[0]

The offsets themselves differ by game version, so I didn't include them in this post. Instead, keep in mind two traps I ran into.

• The launcher and the actual game were different processes. No matter how much I dug through the PlantsVsZombies.exe that Steam launches, the sun value never showed up. The real game was popcapgame1.exe, which that launcher starts in turn. If you can't find a value, check the process list first.
• Don't trust the "playing" flag too much. The shop screen between levels also read as "playing" in memory. The incident this caused is in Step 4.

Step 2. The AI decides, the harness clicks​

If you tell the AI "click coordinates (412, 233)," there are too many ways for it to go wrong. So I split the roles like this.

• What the AI does: decide what to plant where (e.g., "Peashooter in row 2, column 3"), click menus, tutorials and reward screens, and write notes on rules it has learned
• What the harness (program) does: read state from memory, turn "row 2, column 3" into screen pixels and click, reject plantings that break the rules (not enough sun, recharging, a plant already in that cell) and send the reason back to the AI, and automatically collect falling sun

Sun collection works off the screen. It captures the game window, finds blobs of "very bright yellow" pixels and clicks their centers, a simple approach. If you make the AI collect sun too, it's a few seconds late every time and the economy collapses. For the same reason, in minigames that are all about reflexes, like Whack a Zombie (2-5), the harness clicked zombie positions directly, and I told the AI about it.

I learned three things here.

1. Run in windowed mode, not fullscreen. In fullscreen, captures arrived later than the actual screen, so it clicked spots where the sun had already disappeared. Switching to windowed mode fixed it immediately.
2. Re-read moving targets right before clicking. On the conveyor-belt level (1-10), the cards keep sliding, and clicking where they were a few seconds earlier made 30% of plantings fail (14 out of 48). After re-reading state right before each click and accounting for the sliding card's real position (x + slide offset), it cleared the very next game.
3. Enforce the AI's response format. Opus sometimes put an explanatory sentence before the JSON, or wrote such long notes that it hit the token limit and the response broke. Once I locked the format with the option that specifies an output schema, the problem went away.

Step 3. Put both models under the same conditions​

For the comparison to mean anything, only the model should differ and everything else should be the same. These are the conditions I matched.

• Same prompt, same state text, same 800x600 screenshot, same harness
• A fresh game profile for each model (OPUS, ASTRA), both starting from the same main menu
• Real-time play: the game doesn't pause while the AI thinks. Response speed counts as part of skill

First, here are the results of running 1-1 through 1-4 side by side.

Up to here it's close to a draw. The gap opened up as levels got harder and the runs went on for hours without a break. Opus finished all 50 levels with only the three assists listed above, while Astra stalled at 2-9 under the same conditions after a string of losses. Since Claude was the one that went all the way under the same conditions, Claude takes the EP.1 point.

Step 4. Install stop mechanisms for when nobody is watching​

In a multi-hour unattended run, "getting trapped in a weird state" was a bigger enemy than game skill. Here's what actually happened, and the mechanisms I added afterward.

• The monitor turned off, but the AI kept thinking. In the middle of 2-4, the gaming PC lost its monitor signal and every capture came back black. The AI spent 1 hour 50 minutes waiting while staring at a black screen, making 490 calls and spending about $9 in the meantime. Afterward, I made it stop calling the AI (zero cost) when it detects a black screen or an abnormal window size, and stop everything if that lasts more than 2 minutes. I also installed a virtual monitor driver so the display stays alive even when the physical monitor is off.
• In the shop, it mistook the Golden Watering Can for sun. The Crazy Dave shop after 5-4 read as "playing" in memory, so automatic sun collection stayed on. It kept clicking the yellow Golden Watering Can thinking it was sun and was stuck in a "not enough money" window for about 8 minutes. I changed auto-collection to run only inside levels.
• Nobody clicked a single key, and everything stalled for 5 hours. It had effectively won 3-4 at around 1:40 a.m., but nothing was there to click the reward (a key) that the last zombie dropped. In plan mode (Step 8), the AI's turns were paused during play, but clicking rewards was the AI's job. The win-probability watcher and the supervisor script both decided "it's playing, so it's fine," and it sat like that until 7:03 a.m. I changed it so the AI handles things directly when there are zero zombies and a non-sun item is on the lawn, and added a watchdog that sends an alert and restarts the segment if there's no action, result or screen change for 15 minutes.

In short, an unattended agent needs a mechanism that "wakes it up when nothing happens" just as much as one that "stops it when it fails."

Step 5. When it gets stuck, record everything you change​

Both models got stuck somewhere, and each time a human changed something. If you don't write down what you changed and why, you can't later separate "AI skill" from "the share a human helped with."

Where Opus got stuck: Dr. Zomboss. On the final level, 5-10, it lost 28 times in a row at 1x speed. It could only wear Dr. Zomboss's HP down from 40,000 to 33,180, because it was too busy dealing with fireballs, iceballs, Bungee Zombies and Zombonis to add more attacking plants. Once I slowed the game to 0.5x just for the boss fight, it won on the first try, in 18 minutes and 96 calls. This assist lets the game run at only half speed while the AI thinks, so I disclosed it in the video as well.

Astra stopped for three reasons.

1. 429 (server busy) responses. On the same account, calls that included images were repeatedly rejected with 429, only for Astra. The 429 stretches I measured ranged from 5 minutes to 100 minutes, mostly 15 to 30 minutes. Only 33% of the weekly usage had been used, so this wasn't a quota problem; it was server congestion. From 17:21 to 19:35 on October 26 it went on for more than two hours, and 9 of the 12 games lost on 2-6 went by with almost no AI decisions.
2. Slow responses. Astra calls through Codex CLI averaged around 17 seconds in this period. In a real-time game, 17 seconds is long enough for a zombie to walk halfway across the screen.
3. The fallback model's mistakes, and mine. When Astra couldn't respond, I had GPT-6 Luna on the same account decide instead, but Luna would click an empty slot on the seed selection screen and think it had "filled" it, or pick mushrooms for daytime levels. On top of that, I added a rule: "if Astra takes more than 10 seconds, switch to Luna." With Astra averaging 17 seconds, Luna was effectively always deciding. On 3-2, 34 of 37 decisions were Luna's, and there was no progress. When I went back through the logs, all 21 wins up to that point had been games where Astra decided every turn, and Luna had zero wins. So I removed the time limit and had it wait for Astra again.

Assists added by a human, and what happened

That's how Astra got to 24 levels (3-4). At 7:15 a.m. on October 27, the user ended the run, saying "going further is pointless."

Step 6. Fold likely losses early with a win-probability model​

Watching lost games to the end felt like wasted time. If you restart games whose outcome is obvious and move on, you learn more in the same amount of time. The problem is deciding what counts as "obvious."

1. Use past games as training data. From the 135 games both models had played so far, I pulled 3,473 game states and labeled each with that game's final result.
2. Pick features a player who knows the game would look at. Wave progress, lawn mowers lost, total zombie HP and the HP of nearby zombies, the position of the frontmost zombie, number of attacking plants, number of Sunflowers, rows with zombies but no attacking plant, zombie HP per attacking plant, and the number of zombies near the house.
3. Logistic regression is enough. It read memory every 2 seconds, computed the win probability and showed it in the right-hand panel (Step 7).
4. Validate the threshold against past records before setting it. This was the most important step.

At first I had it restart immediately at "below 30% win probability for 10 seconds," and it kept cutting games off around the 1-minute mark, never even reaching the middle game. When I replayed the past records, this threshold turned out to wrongly cut 24 of the 57 games that were eventually won. Adding a 90-second grace period at the start of each game, during which it never cuts, brought the wrong cuts down to 9 of 57.

The restart clicks Menu → Restart Level → Restart, just like a person would. If the AI was clicking a menu at the same time, the windows overlapped and it failed, so during a drop I locked the AI's clicks, put down any seed it was holding with a right-click, and then ran the sequence. Restarted games count as losses, and the AI was told only that "it was restarted because the win probability was low." Minigames and boss fights were excluded from the win-probability model.

Step 7. Show the win probability and the reasons for actions next to the game screen​

When you watch an AI play alone for hours, you keep wondering "why did it plant there just now?" The same goes for anyone watching the recording. So I put a win-probability panel to the right of the game window, and a red box over the game where the AI just clicked. With just Windows and Python, you can build this with no extra installs (tkinter, pywin32).

The structure is simple. The AI loop sends the win probability and the action and reason over HTTP, and the control server on the gaming PC draws a panel window and a transparent box window.

Game memory/screen → AI loop (can be another PC): win probability every 2 s, action + reason every turn
        │ HTTP POST /overlay {title, p, sub, reason, boxes}
        ▼
Gaming PC control server: ① right-hand panel window ② transparent box window over the game

7-1. Create an always-on-top panel window​

import tkinter as tk
root = tk.Tk(); root.overrideredirect(True)        # no border or title bar
root.attributes("-topmost", True); root.attributes("-toolwindow", True)
big = tk.Label(root, text="Win rate --", fg="#fff", bg="#111",
               font=("Malgun Gothic", 34, "bold")); big.pack()

The HTTP server runs on a different thread, so it must not touch tkinter directly. Put the received values into a queue.Queue, and have the tk side pull them out and draw with root.after(50, poll). I used green for 50% and above, yellow for 30% and above, and red below that, with the bar length showing the win probability.

7-2. Make the panel follow the game window​

x, y = win32gui.ClientToScreen(hwnd, (0, 0))
_, _, w, h = win32gui.GetClientRect(hwnd)
root.geometry(f"{W}x{H}+{x + w + 12}+{y}")          # right next to the game window

On a 4K monitor at 150% scaling, you need to turn on SetProcessDpiAwareness(2) for the coordinates to line up. And always keep the panel outside the game area. The AI sees the game area through screen captures, so if the panel covers the game, the AI mistakes it for part of the game screen.

7-3. Show a click-through red box over the game​

bw = tk.Toplevel(root); bw.overrideredirect(True); bw.attributes("-topmost", True)
KEY = "#ff00fe"; bw.configure(bg=KEY); bw.attributes("-transparentcolor", KEY)
hw = win32gui.GetParent(bw.winfo_id())
ex = win32gui.GetWindowLong(hw, win32con.GWL_EXSTYLE)
win32gui.SetWindowLong(hw, win32con.GWL_EXSTYLE,
                       ex | win32con.WS_EX_LAYERED | win32con.WS_EX_TRANSPARENT)  # click-through

Draw only rectangles in a window whose background is set to the transparent color, and hide it after 2.5 seconds. You need WS_EX_TRANSPARENT so clicks pass through the box to the game.

7-4. Keep it invisible to the AI​

This is the most important part. When the AI requests a screenshot, hide the box window, wait for the signal that hiding is done, capture, and then show it again. I opened AI-bound captures taken while a box was up and confirmed there were no red pixels. Skip this and the AI reads its own markers as objects in the game.

7-5. Send actions and reasons from the AI loop​

send_overlay({"title": "3-2 · Astra decision", "p": 0.47,
              "sub": "Wave 5 · restart if below 30% for 10 s",
              "reason": "[Astra] Action: Peashooter → row 2, col 3\nReason: a Conehead is coming down the top row, so block it",
              "boxes": [[202, 165, 278, 249, "Peashooter"]]})

The reason text is the thinking field that was already in the AI's response, used as is. Asking it to write a separate explanation would add more calls.

Here are the problems I ran into.

• Restarting the control server orphaned the recording process it had launched, and the files got corrupted. I switched recordings to fragmented mp4 (-movflags +frag_keyframe+empty_moov) and had the server clean up only this game's recordings on startup. Two recordings corrupted before that (a few minutes of 3-2) never played back.
• At 150% scaling, panel text got cut off. Make the window tall enough (470px).
• The panel, recording and clicking were all tied to one server, so turning off just the panel meant shutting down the whole server. Next time I plan to split the panel into its own process.

Step 8. Plan mode: the AI designs, the machine executes​

In a real-time game, if the LLM thinks about "what should I plant next?" every turn, it's always late by however long the response takes. So I split the roles again. The AI writes a plan before the game starts, and once the game starts, a program executes that plan at machine speed.

1. The AI writes the plan on the seed selection screen. It searches the web for a guide to that level itself, looks at its own past game records (seeds taken, planting order, results) and previous plans, then writes executable JSON. It contains the seeds to bring, an ordered placement table (plant, row, column, reason) and emergency rules (e.g., "if a zombie reaches this cell, Cherry Bomb").
2. Seed picking also happens automatically, following the plan. It reads the unlocked cards and clicks the seeds in the plan. When it read cards while the camera was still moving, noise got picked up as unlocked cards, and once Cabbage-pults and Melon-pults that weren't in the plan got in. I fixed it to read cards only after they're fully on screen.
3. The executor reads memory every 0.3 seconds and plants according to the plan. Emergency rules come first, then it fills empty cells from the top of the placement table. When it's short on money it saves sun for that item, replants cells that got eaten, and lays down Lily Pads on water and Flower Pots on the roof on its own. Those mechanical steps are the only decisions the executor makes.
4. After a loss, the AI rewrites the plan before the next game. I required it to fill in a "cause" field every time.

The first executor had one gap. Because it only filled the placement table from the top, it would plant Sunflowers first, and time would pass with no attacking plant in a row where zombies had come in. The user asked, "why doesn't it plant a Peashooter first in the row the zombies are coming down?", and I added a rule: if a zombie enters a row with no attacking plant, plant that row's first attacking plant before anything else. I also wrote this rule into the plan-writing instructions so the AI would put an attacking plant for each row in the placement table.

The effect showed up in the numbers right away. 3-2 was a level it had lost 13 times, and in plan mode at 2x speed, using the plan Astra wrote (two columns of Sunflowers, two columns of Peashooters, Snow Pea, Wall-nut, and Squash and Cherry Bomb for emergencies), it won for the first time in 218 seconds.

Cranking up the speed wasn't always better. When I raised it to 5x, the number of plants at the same wave dropped to 6-12 (versus 21 in the 2x winning game). Uncollected sun on the lawn went from an average of 0.7 to 1.4, which suggests sun collection couldn't keep up with the speed. The levels were also different, so I can't say for sure, but prioritizing clears, I dropped back to 2x and shortened the sun-collection interval from 0.35 seconds to 0.15 seconds.

Step 9. Get a recap of every game in Slack​

Logging in remotely every time to check "how's it going?" during an overnight run is inefficient. So I had a recap posted to a Slack channel at the end of every game. Wins post immediately; losses post right after the AI writes its next plan (which doubles as its own recap).

Here's what went into each recap.

• Level, result, attempt number
• Time taken (speed multiplier and game time listed separately)
• The model that wrote the plan, and the seeds it brought
• Number of plantings, max plant count, average sun
• Win-probability trend (start → low → end)
• A factual record of the loss and the record on this level
• The AI's cause analysis and a summary of the next plan
• Execution diagnostics: time spent waiting to save sun for each plan item, items it couldn't plant and why, seeds in the plan that weren't brought, and sun left on the lawn

Adding the execution diagnostics paid off. The bug "a catapult that wasn't in the plan got in, so it couldn't plant attacking plants" was found because the AI wrote it in the cause field itself. Separately, I ran a watch script that sends the game screen and progress every 3 hours. It's an ordinary script with no LLM, so it costs nothing.

Costs: API and subscriptions are counted differently​

Opus 5.5 (API): finishing all 50 levels comes to about $104.9 at API prices. By chapter:

Harness bugs and the black-screen stretch (122 minutes, 552 calls, $10.7) are excluded from this table. The actual charges came out of Anthropic API promotional credits, so I didn't pay anything separately, and this month's usage shown in the Console is $127.60. The Console amount covers the whole month, so it isn't the same number as the table above.

Astra (ChatGPT Pro subscription + Codex CLI) isn't billed per call. Instead of money, what ran out was time. Even with weekly usage at 33%, 429 congestion stalled it for up to 100 minutes at a stretch. Converting just the 1-1 to 1-4 comparison at API prices gives $4.01 (Opus: $1.11), but most of that comes from the Codex default instructions attached to every call, so don't read it as a comparison of model prices.

The takeaway: for a multi-hour real-time experiment, "a path that doesn't get blocked" mattered more than "a cheap path."

Failures and fixes at a glance​

What I'm taking to the next game​

The biggest lesson this time is the habit of deciding up front what to give the AI and what to give the program. Read state from memory or structured data, let the program handle clicks and repetitive actions, and leave planning and judgment to the AI. And if it's going to run unattended, put in stall watchdogs, a supervisor script that stops on failure and a per-game recap from day one. This time, I added them one by one only after things went wrong.

I'm also changing how I compare. Starting next episode, I'll call both models through the same access method (API vs. API, or subscription vs. subscription), pause the game while the AI thinks so response speed doesn't decide the match, run on the same seed in the same time window, and fix the allowed assists (speed, automatic actions, fallback models) before the start and not change them midway. Adding assists every time something gets stuck, like in this PvZ run, ends up comparing "who got more help" rather than "who played better."

From the next episode on, I'll publish the rules before the match starts. I'll state at the top of the video and the post how much the AI does on its own, what the program does on its behalf, and that no human steps in during the match.

Update (October 28): how the harness actually changed for the next match​

After publishing this post, I started the second match (Frostpunk, a game where you run a city for 48 days) and put the lessons above into practice. Here is what carried over and what turned out to be new.

What carried over

What was new

• Saving and rolling back: A level that lasts a few minutes can simply be replayed, but a 48-day game is far too long to restart from scratch after a loss. The harness saves under a new name every day and rolls back to a designated save after a loss.
• A daily plan: Reacting turn by turn missed problems that blow up days later (coal, food, discontent). Every morning the AI writes a plan and rereads it each turn.
• The program does the math: The harness calculates how many hours until a resource runs out and how fast discontent rises per day, and tells the AI.
• When stuck, the AI studies on its own: Instead of a human giving hints, the AI searches the web for guides when it gets stuck and writes its own notes.

Even so, the rules changed mid-match this time too. Every change came from the user, applied equally to both models, and the timing and reasons will be disclosed at the end of the second match's post and video.

Who this is for​

• You use ChatGPT, Claude or Gemini at work and have asked yourself "it worked yesterday, why not today?"
• You call AI APIs from n8n, Make or your own code, and errors suddenly start piling up
• You're an instructor or team lead who needs to tell students or teammates "if the AI acts weird, check this first"

All you need is a browser. To use the script in Step 4, you also need Terminal on a Mac (it comes preinstalled). I opened and checked every URL and response in this post myself on October 7, 2026.

Step 1. Bookmark the three status pages​

If you start searching only once something breaks, you're already late. Put these three URLs in one bookmark folder ahead of time.

The old address status.anthropic.com now redirects to status.claude.com. It's cleaner to bookmark the new one.

Step 2. Look at the banner color and text at the top​

When you open a status page, the overall status appears in one line at the very top.

This is the Claude status page on October 7, 2026. If the green banner at the top says All Systems Operational, everything is running normally. Here's roughly how to read the messages.

The bars below show each service's history for the last 90 days. On this screen, claude.ai's 90-day uptime was 99.46%. The scattered red and orange bars also tell you that outages happen more often than you might think.

Step 3. Check whether the component you use has its own incident​

Even when the overall banner is green, just the feature you use might be down. Find the component you use in the list below the banner.

• If the problem is in the ChatGPT app, look at the ChatGPT component.
• If you call the API from code or n8n, look at the API components. OpenAI splits these by feature, such as Chat Completions and Responses.
• Claude lists claude.ai (web and apps) and the Claude API separately. Some days the web works and only the API fails.

If everything here is normal too, that's when you start suspecting your side (API key, billing limits, prompt, code). Sticking to this order alone cuts down on debugging in the wrong place.

Step 4. Use a script to check all three services at once​

Besides the page meant for humans, the OpenAI and Claude status pages also expose an address for programs to read. Open the URLs below in a browser and you get a one-line result.

https://status.openai.com/api/v2/status.json
https://status.claude.com/api/v2/status.json

Here's the actual response on October 7, 2026 (Claude).

{"page":{"id":"tymt9n04zgry","name":"Claude","url":"https://status.claude.com","time_zone":"Etc/UTC","updated_at":"2026-10-07T00:45:09.742Z"},"status":{"indicator":"none","description":"All Systems Operational"}}

An indicator of none means normal. During an incident it changes to minor, major or critical. Google uses a different format, so you have to look in https://status.cloud.google.com/incidents.json for unresolved incidents (no end value) that involve Gemini.

Checking all of this by hand every time got tedious, so I wrote a script that does it in one go. Paste the whole block below into Terminal and it creates an ai-status.sh file on your Desktop.

cat > ~/Desktop/ai-status.sh <<'SCRIPT'
#!/bin/bash
# Check the status of AI services in one go. (Uses macOS built-in curl and python3)
for pair in "OpenAI|https://status.openai.com/api/v2/status.json" "Claude|https://status.claude.com/api/v2/status.json"; do
  name="${pair%%|*}"; url="${pair#*|}"
  curl -s -m 10 "$url" | python3 -c "import sys,json; d=json.load(sys.stdin)['status']; print(f\"$name: {d['indicator']} / {d['description']}\")" 2>/dev/null || echo "$name: check failed (check your network or the URL)"
done
curl -s -m 10 https://status.cloud.google.com/incidents.json | python3 -c "
import sys,json
d=json.load(sys.stdin)
open_=[i for i in d if not i.get('end') and any('Gemini' in p.get('title','') or 'Vertex' in p.get('title','') for p in i.get('affected_products',[]))]
print('Google Cloud (Gemini/Vertex): %d ongoing incident(s)' % len(open_))
for i in open_[:3]: print('  -', i['external_desc'][:80])
" 2>/dev/null || echo "Google Cloud: check failed"
SCRIPT
chmod +x ~/Desktop/ai-status.sh

Running it takes one line.

~/Desktop/ai-status.sh

Here's the result when I ran it on October 7, 2026.

OpenAI: none / All Systems Operational
Claude: none / All Systems Operational
Google Cloud (Gemini/Vertex): 0 ongoing incident(s)

If all three lines are normal, the cause is most likely on your side.

If you get an error, start here​

Wrap-up​

When an AI acts up, the order is always the same: check the status page banner, check the component you use, and only when both are normal, look at your side. With three bookmarks and a one-line script, this check takes under 10 seconds.

Pickle is an agent with its own browser and phone number​

Pickle goes a step beyond a chatbot that answers questions. According to its official help pages, Pickle works on websites like a person, using a real web browser, and places phone calls itself where the web won't do. Connect your email and calendar and it reads them to find things to take care of before you ask; if your friends use Pickle too, your Pickles coordinate plans with each other.

For users in Korea, the biggest difference is price. In Pickle's words, every account in Korea is free, and instead there's a daily usage limit that resets at 4 a.m. every day. The old paid plan (Pickle Plus) is no longer sold. It's made by Pickle, Inc., a startup from Y Combinator's Winter 2025 batch, which started out with AI avatars for video calls and then pivoted to personal agents.

What you need​

• An iPhone (iOS 17 or later) or an Android phone (screenshots are from Android; Pickle is for ages 18 and up only)
• One Google account to connect (I recommend starting with just the calendar)
• A browser on a PC to check the results against

Step 1. Install from the App Store or Play Store and sign up​

1. Install "피클: 나만의 AI 에이전트" ("Pickle: My Own AI Agent," publisher Pickle, Inc.) from the App Store on iPhone or the Play Store on Android. iPhone requires iOS 17 or later. As of October 26 it's a new app with 500+ downloads and 8 reviews on the Play Store, so check the publisher name so you don't confuse it with similarly named apps.
2. Open the app and follow the prompts to sign up. After sign-up, My Pickle → My account shows your name, Pickle ID, phone number and date of birth, so have that information ready.

Step 2. Read what Pickle can do in the first chat​

Once you finish signing up, Pickle sends an introduction in the default chat. The three key points: "I have my own computer, so I can do things like book train tickets, file taxes and place orders on Coupang (Korea's biggest online marketplace)," "I can make calls for you from my number," and "if you connect them, I'll manage your email and calendar too." Right below are suggested connection cards (Apple Calendar, Google Calendar, Gmail).

Step 3. Connect just Google Calendar first​

Don't connect your email, shopping sites and Gov24 (the Korean government's online services portal) all at once. Start with the calendar. The official help page says that when you add a connection, Pickle reads that account's content broadly, and what it reads can stay in conversations, memory and task history. A calendar exposes a relatively narrow slice of your data, and you can verify the results right away.

1. Tap Google Calendar on the connection card in the chat, or go to My Pickle → Apps and services connected to Pickle → +.
2. After you sign in to Google and grant permissions, the switch next to the account turns on.

The connection list includes Google sign-in, Naver Mail (from Naver, Korea's largest search portal), Gmail, Microsoft 365, Google Drive, Naver, Coupang, Gov24, Location and Contacts, and the Android tab separately lists your phone's location, contacts, calendar and photos. Having Naver, Coupang and Gov24 on the default list is what sets it apart most from agents built outside Korea.

A few seconds after connecting, Pickle messaged me first. It pointed out two events tonight and said it had "set up reminders so you don't miss" two deadlines next month. I'll check where those reminders were set up in Step 8.

Step 4. Check the usage limit in the My Pickle tab​

The person icon at the bottom is the My Pickle tab. The top card is the daily usage limit, which goes back to 0% at 4 a.m. every day. When you use it all, the input box turns off; if you don't want to wait, you use a limit reset ticket. I had 1 full reset ticket as a sign-up gift, and every time you invite a friend, you both get 1.

Auto-use for reset tickets is off by default. Tickets are scarce, so it's better to leave it off.

Step 5. Set your disclosure settings first​

Because Pickle can talk to your friends' Pickles, there's a separate screen for deciding how much your Pickle can say about you. Go to My Pickle → Disclosure settings.

The default is "To friends' Pickles: up to everyday updates." Under Connected apps and services you can decide per app whether it's okay to share with other people, and Things never shared with anyone says that sensitive things like health, money, private life, beliefs, exact location and account security are never shared with anyone by default. If you don't have friends on it yet, leave it as is and revisit Per-person settings when you add a friend.

Step 6. For the first task, have it summarize this week's schedule​

I sent this in the default chat input box.

Give me an at-a-glance summary of my schedule this week. Also tell me about any days with overlaps or that are packed.

The answer came in under a minute. It split things into three groups, "overlapping events," "days with packed evenings" and "day-by-day overview," found that a Sunday night lecture and a daily routine event overlapped at exactly the same time, and asked, "Want me to move it?" When I checked against my calendar, every date and time was right.

When I tried OpenAI Dots, a similar schedule briefing took about 4 minutes. Dots pulled in email and Notion and attached what I'd need to prepare; Pickle only had the calendar connected, so it only summarized the schedule. With different connections, speed alone isn't a fair comparison.

Step 7. For the second task, have it research the public web, then verify​

I gave it the same research I used in my Muse guide. I included conditions not to use my personal accounts and not to make any bookings or inquiries.

Don't use my personal accounts like email or calendar; research using only public web information. Find 3 rental spaces in Seoul where I could hold a hands-on AI workshop for about 20 people, and compare location, capacity, published price and source link in a table. Don't book or contact anyone, and if the price isn't published, write "not published."

While it works, "Searching the web," "Reading page" and "Thinking" take turns under Pickle's avatar. About 2 minutes 15 seconds later, a table arrived. You have to swipe the table sideways to see the price and source columns.

Below the table were notes on each space's setup for hands-on work, and a SpaceCloud (a Korean venue rental platform) link card for the first space.

I opened each source and checked.

2 of the 3 were right, and 1 had both the address and the published-price status wrong. The "not published" in particular looks plausible because it reuses the exact wording from my prompt. When you get a table, click each source link at least once. It did follow my conditions: the first line of Pickle's answer said, "I didn't access any personal accounts and didn't make any bookings or inquiries."

Step 8. Check the tasks Pickle scheduled on its own​

Pickle saying it had "set up reminders" in Step 3 bothered me, so I asked.

Earlier you said you set up reminders for November 6 and 16. Where did you set them up? Did you create new events in my Google Calendar?

The answer: "I didn't add or touch anything in your Google Calendar; I set them up as scheduled reminders inside Pickle." It also explained that it had moved the dates up so it would message me in chat two to four days ahead rather than on the deadline itself.

To check for yourself, tap Pickle's avatar at the top of the chat screen, then the clock icon in the middle. Under "Tasks scheduled in advance," there were two one-time tasks and a recurring task, "Morning briefing (every day at 7:08 a.m.)." I didn't create the morning briefing; it's on by default. You can turn each one off with its switch, and create your own scheduled tasks with + at the top right.

When an agent says "I've set that up," make a habit of asking where. Pickle didn't touch my calendar this time, but with a connection that has calendar write access, the answer could be different.

Step 9. Check usage again after handing off tasks​

After three tasks (the schedule summary, the web research and one question), usage in My Pickle was 1%. According to the help pages, routine things Pickle does on its own, like the morning routine, don't count against the limit, and calls Pickle places for you have a separate daily cap.

Before you hand off tasks that need logins and payments​

On day one I didn't connect services that need a login, like Coupang or Naver; connecting them myself the next day is covered in Steps 10 to 12. Tap Coupang in the connection list and you get an intro saying "log in once and a single 'I'm out of toilet paper' takes care of everything from a Rocket Delivery (Coupang's fast-shipping service) order to delivery tracking," along with a reorder example.

Before handing anything off, check three things in the official help pages.

• Passwords don't go in the chat; you enter them in the login card Pickle sends. The help page says the input is encrypted with a key created on your phone and stored in a vault, and isn't passed to Pickle (the AI). Pickle can read your username.
• For payments, it says it will first show the item and amount on a card and ask for approval with a button, and if the amount goes up right before payment, show the increase and ask again.
• Cards and connected accounts can only be used during the access period (1 day up to 30 days), and if you don't open Pickle during that period, access turns off on its own. That screen has no button to turn it off right now, so to stop it from being used, you have to delete the card or disconnect.

If you're not sure what to hand off, check the Explore tab. Tasks that lots of other users have handed off, like "Cancel subscriptions I don't use," "Call 080 numbers to opt out of ad texts for me" (080 is the toll-free opt-out line on Korean marketing texts) and "Screen my calls first," are listed along with how many people have handed them off.

Step 10. Connect services that need a login one at a time with a login card​

The next day (October 27), I connected SRT (a Korean high-speed rail operator), Korail (Korea's national railway), Coupang, Yanolja (a Korean travel and accommodation booking app), Megabox (a Korean cinema chain), Aladin (a Korean online bookstore), Daiso Mall, Gov24, GitHub, Notion, Slack and X, one by one. The method is the same for each service.

1. Send the service and your username in the chat.

I want to connect SRT. My username is ○○○○. Send me a login card.

2. Pickle shows a secure login card with your username pre-filled. Tap the password field and your phone's password manager autofill pops up (I used 1Password, approved with my fingerprint). Don't type the password in the chat.
3. Tap Log in and Pickle logs in, then reads your account status right away. For Korail it told me I had no mileage and no waitlisted tickets; for Megabox, 2,110 points and 2 discount coupons; for Aladin, KRW 1,400 in mileage and 1 order from April.

If you can't remember your username, just ask. For Coupang, Pickle searched my connected Gmail and showed a list of usernames that looked like ones I'd signed up with; I picked one and the card arrived. Glance at the username field on the card before logging in: once, leftover text from the chat input box got mixed in.

Step 11. If you get stuck on verification, ask Pickle to switch methods​

What took longer than logging in was two-factor verification. Here's exactly where I got stuck and how I got through.

Pickle handling email verification codes on its own once your email is connected is convenient, but it's also a big deal. Connecting your email effectively means handing over the keys to log in to other services too. Gov24 showed a screen asking me to change my password, and I decided to make account decisions like that myself rather than leave them to Pickle. For Uber, the second-step SMS code never arrived on my phone, so I couldn't finish connecting.

Don't trust the check marks in the list. Lotte Cinema (a Korean cinema chain) failed to log in because the password was wrong, yet it had a check mark in the Connected list. Slack hit the free-plan workspace's app install limit (10) and showed "You can't add any more apps," but the list still said connected, and later Slack read showed up in the access log. The more reliable way to confirm a connection is to have Pickle read something from that service.

Step 12. Check what Pickle did on its own after connecting, and your usage​

Once I finished connecting, Pickle started with things I hadn't asked for.

• GitHub: Right after connecting, it analyzed all my repositories and asked, "One repository's GitHub Pages build is in an error state, so its public page may be stuck. Want me to look into the cause and rerun the build?" I haven't checked yet whether that's right, and I didn't hand off the build. When you connect, the first option in repository selection is "All repositories," and it includes write access to code, issues, PRs and Actions, so it's safer to pick only the repositories you need.
• Slack and Notion: It skimmed both in the background, picked out "three things you need to deal with now" (replying to a colleague about documents, a disk warning on a remote server, and replying to an outside lecture offer), and offered, "Want me to handle these for you right now?" That answer included a colleague's personal email address verbatim. Keep in mind that if you connect a work Slack, other people's information goes into Pickle's memory too.

Three tasks in Step 9 used 1%, but connecting 21 apps and services used up 100% of the daily limit. Login cards, verification and post-connection analysis all count against the limit. Don't do all your connections in one day; spread them out, starting with the services you use most.

Finally, look at the access log screen. It records in time order which services Pickle read or connected and when, and the last-7-days totals showed 951+ reads, 15+ sends and 0 deletes or changes. Check from time to time that deletes/changes is 0 and that there's nothing in sends you don't know about.

How it compares with Grok Bot, Muse and Dots​

All four products bill themselves as "an always-on agent that works for you on its own computer (browser)." Where they differ is where you can use them, how much they cost and which services they can reach. The Pickle column is based on my own use and the official help pages; the rest are based on official docs and my earlier write-ups as of October 26, 2026.

To boil the table down to one line: Dots and Grok Bot lead on raw capability and breadth of connections, while Pickle has the edge on Korean everyday services, phone calls and price. For Muse, not being officially available in Korea is still the biggest barrier.

My take after using it​

Three things I liked. First, it took under 10 minutes from install to first result and cost nothing. Compare that to agents from outside Korea, where I first had to get past a VPN or a plan costing over KRW 100,000 a month. Second, it's proactive: as soon as I connected the calendar, it found a schedule conflict and set up deadline reminders on its own. Third, Naver, Coupang and Gov24 are on the default connection list, and it even makes phone calls for you. The everyday chores people in Korea put off really do pile up in places like these.

The downsides are clear too. 1 of the 3 web research results was wrong, and the wrong part used a plausible phrase like "not published," which is easy to miss if you don't verify. Also, with something like "I've set up reminders," it wasn't clear at first what it did and where. Before handing off anything involving payments or logins, I recommend starting with small tasks and checking the results.

If you get stuck​

What I haven't checked yet​

• The actual call quality and result summaries of calls Pickle makes for you (I didn't place any this time)
• The actual ordering and payment flow (I only went as far as connecting logins; I didn't hand off orders or payments)
• What each of the "15+ sends" in the access log was (I haven't opened them yet)
• Whether the GitHub build error it flagged is real
• Friends' Pickles setting up plans with each other
• The order of the sign-up screens (I started with an account that was already signed up)
• Which AI model Pickle uses (I couldn't find it in the official help pages)

Sources​

• Pickle help: What is Pickle, Handing tasks to Pickle, Confirmation before payment, Connecting apps and services, Saving site logins, Usage limits, Checking your plan, Access period
• Pickle, Y Combinator company page
• Pickle on Google Play
• Grok Bot: xAI's Grok Bot introduction, Grok Bot overview, Plans and usage, Phone feature announcement
• Muse: Meta Muse announcement, Muse security, Muse subscription help
• Dots: Introducing Dots, Dots developer docs, Getting started with your Dot

Who this is for​

• You're on Claude Pro or Max and weighing whether moving to Team is worth it
• You subscribed to Team but couldn't find on screen what changed compared with a personal plan
• You want to try a shared Claude (@Claude) that anyone on the team can call from a Slack channel, or on-call for incident response
• Your staff have been using their own personal Claude plans, and as you move them to a company team plan you're deciding between Claude Team and ChatGPT Business (see the FAQ)

Here's what you need.

• A claude.ai account that belongs to a Team organization. To see the admin screens (Steps 3, 5, 6, 8), you need the Owner role in that organization
• A personal plan account to compare against (optional). If the same email still has a personal plan, you can switch to it directly from the account menu

The screenshots show Claude's Korean interface. In the text I use the English menu names, and quoted on-screen messages are translated from Korean, so the exact English wording in your UI may differ slightly.

At a glance: what only Team has​

I combined the plan comparison on the official pricing page with what I saw on screen. "Personal" means Free, Pro and Max (5x, 20x).

On the other hand, some things are not Team-only. I've listed just the ones that are easy to mix up.

As of the October 25, 2026 pricing page, a Team Standard seat is $20/month billed annually ($25 billed monthly), and a Premium seat is $100/month billed annually ($125 billed monthly). It's aimed at teams of 2 to 150 people. Usage limits aren't shared across the team; they apply to each seat separately.

Step 1. Switch to the Team organization from the account menu​

Click your name in the bottom left of claude.ai to open the account menu. If the same email has both a Team organization and a personal plan, you pick the organization here.

Three places change as soon as you switch.

1. Sidebar: Team gets On-call. The Routines entry that sat there on personal Max moves under More on Team
2. Account menu: Team gets Organization settings and Analytics. Personal Max has Usage and Resubscribe to Max instead (the latter appears because cancellation was scheduled)
3. Projects screen: Team gets Organization and Shared with me tabs next to My projects. Personal Max has no tabs

Step 2. Open the on-call screen​

Click On-call in the sidebar or go to claude.ai/oncall. If you open the same address with personal Max, you only get a notice saying "This page isn't available for your organization yet."

On-call puts Claude next to your team's incident-response on-call person. During setup you choose one or both of two modes (official docs).

• Alert monitoring: watches monitoring tools such as Datadog, Sentry and PagerDuty, and posts what it finds to a designated channel
• Auto-join incident channels: set a channel naming rule like incident-, and Claude joins new public channels created with that name on its own and investigates alongside you without being tagged

Things to know:

• Your team's on-call rotation stays as is; Claude works alongside the person on call
• On the Team plan, any organization member can open the settings screen. Changes that affect the whole organization can only be saved from an account with permission
• On-call work is billed to organization usage, and you can cap it with a monthly spend limit
• Naming rules apply only to public channels. For private channels, you have to invite Claude directly with /invite @Claude in the channel

Step 3. Open the Claude Tag (@Claude) settings screen​

Go to Organization settings > Claude tag (claude.ai/admin-settings/claude-tag). On an owner account, you'll see a Start setup button and a 4-step guide (connect a Slack workspace, connect GitHub, buy usage credits, start Claude Tag).

Claude Tag lets anyone in a Slack channel call @Claude and hand it work. It can reproduce a bug and open a PR, turn a thread where a decision was made into a document, or pull together a project status update. Progress is posted to the thread as a checklist that everyone in the channel can see. The official docs state plainly that this feature works only on Team and Enterprise, not on Free, Pro or Max (Claude Tag overview).

Here's what you need before you start (setup guide).

The cost structure is where it differs most from personal plans. Here's what the FAQ on the settings screen says.

• It's usage-based billing, not per seat. Work Claude does in channels is billed to the organization
• Not every Slack user needs a Claude seat. By default, anyone in the connected workspace can call it in channels, and owners can restrict it to organization members only
• If someone calls it in a 1:1 DM instead of a channel, it comes out of that person's seat limit
• When the spend limit is reached, Claude stops taking new work and tells the channel. If you don't set a limit, there is no cap

Step 4. Choose visibility when creating a project​

Click New project on the Projects screen. On Team there's a Visibility option at the bottom; on personal Max this field doesn't exist at all.

• Organization: any organization member can find and use the project under the Organization tab on the Projects screen
• Private: only people you invite can use it. When inviting, you choose Can view (view and chat only) or Can edit (including editing instructions and knowledge)

Sharing a project doesn't automatically share the chats inside it. Each person's chats stay private, and you share only the chats you want to show through a separate share link (official help article). If an owner turns off project sharing in organization settings, projects that were already shared become private too.

Step 5. Write organization instructions​

Scroll down in Organization settings > Organization & access and you'll find an Organization instructions field.

What you write here applies to every conversation in the organization and takes priority over each person's personal preferences. It can be up to 3,000 characters, and the screen notes that changes can take up to an hour to take effect. This is where you set rules the whole team should follow in one go, like "never include customer personal data in answers" or "always start reports with a table." Personal plans only have personal preferences that apply to you alone.

Step 6. Manage Skills and plugins at the organization level​

Go to Organization settings > Plugins & Skills. There are four tabs.

You can create and use Skills on personal plans too, but distributing them to the whole team at once and seeing usage starts with Team. Sharing a plugin you built with specific colleagues only also works on Team and Enterprise (sharing guide).

Step 7. See team usage in the analytics dashboard​

Open Analytics from the account menu (claude.ai/analytics).

The overview shows weekly active members, PRs created with Claude Code and Cowork sessions, followed by metrics such as usage per member, the most-used Skills and connectors, and "actions Claude performs per prompt." The tabs on the left break out Chat, Claude Code, Cowork, Claude tag and Code review separately. This is the screen for checking who is actually using the seats you bought. Personal plans only have a screen for your own usage.

Step 8. Set usage and spend limits​

Go to Organization settings > Usage.

• Enable usage credits: lets members keep working at usage rates after they've used up their seat limit
• Request usage credits: lets members who hit their limit request credits from an admin
• Per-service spend limits: set limits for services that run automatically. In our organization, Claude Code Review was set to Unlimited

Code Review is a service where Claude automatically reviews PRs in your GitHub repositories and leaves comments and check results on problematic lines. An owner has to turn it on, and a review starts when someone with write access comments @claude review on a PR. Reviews don't approve or block PRs (official docs). Since Unlimited appears to be the default, it's safer to set a limit in this table before turning it on.

Setup to do right after subscribing (added October 26, 2026)​

From here on is what I did after subscribing to Team and actually bringing teammates in. It follows almost the same order as the Get your team on Claude checklist (members, customization, spend tracking) at the top of Organization settings > Organization & access.

Step 9. See usage per member​

The admin screens (Organization settings) don't show usage per person. You have to go to Analytics (claude.ai/analytics).

You can download per-person data as a file with Export on the Productivity tab and Download CSV on the Usage tab. Two things I couldn't see on these screens:

• What percentage of their seat limit (5-hour and weekly) each person has used: I couldn't find this anywhere in the admin screens or analytics.
• Usage by people who run Claude Code with an API key instead of logging in: the screen notes that it's recorded in the Console organization, not in this dashboard.

Step 10. Invite people without a company email (Gmail)​

When I tried to invite an outside collaborator by their personal Gmail by entering the address in Organization settings > Members > Add member, I got the error "You can only invite emails from @datapopcorn.ai." By default, only the domain of the account that created the Team is allowed. Only the owner account that created the team has to be on the company domain; you can bring in members by adding their domain.

1. In Organization settings > Organization & access > Domains, click Add or edit domains
2. Enter gmail.com, then click Add domain and Save
3. Go back to Add member and invite the Gmail address

The Discoverable column on the gmail.com row shows Not allowed. Letting people find and join the organization without an invite only works for the company domain. The only people who actually get in are the ones you invite.

The invite dialog says "Charges for new team members are prorated from the date they're added." We had bought 5 seats in advance, so each invite showed up as the number in 5 seats (n available) on the Billing screen dropping by one. Invites that haven't been accepted yet also count as a seat.

Step 11. Add a second owner​

The first item on the checklist is Add another owner. If there's only one owner and that account gets locked, nobody can manage organization settings, billing or members. We created the team with a shared account, so we added the CEO's personal account as another owner.

In Add member, enter the email, set the Role to Owner and send. There are three roles.

Until the invitee accepts from their email, they stay under the Members > Pending tab, and owner permissions start only then.

Step 12. Claim your monthly API credits (up to $500)​

The Team plan comes with monthly API credits, but they don't arrive until you connect them yourself. If the API credits section in Organization settings > Billing shows "Connect an API organization to receive credits" and a Connect organization button, you haven't claimed them yet.

1. Click Connect organization
2. Choose the Claude Console organization that should receive the credits. We chose the organization that already had our startup credits. If you don't have a Console organization, create one in the Console first
3. Review the additional credit terms at the bottom of the dialog and click Connect organization

As soon as we connected, a notice popped up saying "Your first API credits of $500 USD have been added," and the billing screen changed as shown below.

Per the official docs, here are the conditions you need to know.

Step 13. Organize the Console so credits don't leak​

The monthly credits vanish if unused, and every key in an organization draws from the same balance. So we split the Console organization that receives the credits by purpose.

1) Create a workspace per purpose. In the Console > Organization settings > Workspaces > Create workspace, you just pick a name and a color. We created n8n (automation workflows) and 콘텐츠 ("Content", for content work such as scripts and summaries). The emergency key for Claude Code stayed in the existing Default workspace.

2) Put a monthly spend limit on each workspace. Select a workspace, then enter an amount under Manage > Spend limits > Change limit. We set $250 on each of the two. Together they don't exceed the $500 we get each month, so even if an automation runs wild, it can't eat into the other credits we've kept for Claude Code emergencies.

Spend limits reset on the 1st of each month (UTC), while credits arrive on your billing cycle (around the 20th for us). Since the dates differ, it's better to set the limits generously.

3) Create workspace-specific keys. In API keys > Create key, set the Scope to that workspace, and the key works only in that workspace with limits applied based on that workspace. Expiration defaults to 30 days, so for automation, choose Custom and set it long (we used October 18, 2027, when our Team discount ends). The key is shown only once, so save it to your password manager right away and never paste it into chats or documents.

4) Connect it where it's actually used. We put the n8n workspace key into n8n under Credentials > Anthropic and confirmed the connection test (Connection successful). Don't put it anywhere lots of people come and go, like a teaching n8n instance shared with students.

The official docs recommend three ways to make the credits go further.

• Pick the right model for the job: Haiku for classification or short summaries, Sonnet for writing and general automation, Opus only for hard judgment calls
• Prompt caching: turn it on for tasks that attach the same long instructions every time
• Message Batches API: bulk jobs that don't need an immediate answer are processed 50% cheaper

As a bonus, organizations whose monthly credits exceed $200 get bumped to at least the Build tier for API rate limits.

Step 14. Give Claude work over Slack DM (added October 28, 2026)​

After connecting Claude Tag, the first thing worth trying is a 1:1 DM with the Claude app. Unlike channel work, it doesn't need a top-up.

This table is based on the official docs (billing guide). Reading channels, deciding whether to reply and giving short answers from what it already knows aren't billed either. The monthly API credits from Step 12 don't apply to either of these.

1) Open the Claude app in the Slack sidebar and send a DM. Here's what we sent.

Please summarize the recent alerts in the #infra channel. If there are any recurring issues, point those out too. Please reply politely, without profanity.

2) If you see "Your Claude connection expired," reconnect. Our account, connected through the old Slack app back in August, had expired.

• Clicking Reconnect Claude account opens the connection approval screen on claude.ai
• Check that the Team organization is selected under Switch organization at the bottom, then click Approve
• If your Slack account email and claude.ai account email differ, you get one more confirmation screen saying "doesn't match." If it's the right account, click Confirm and connect. If you connected the wrong one, you can disconnect from the Home tab of the Claude app in Slack
• Reconnecting didn't resume the message sent before the expiration. A notice said "your earlier message couldn't be picked up. Please send it again," so I sent the same request again

3) Check the reply. About 30 seconds later, a reply came into the thread. It organized the channel's top-level posts by date and flagged two recurring incidents and some credits about to expire. It said on its own that it hadn't read the posts inside threads, and asked whether I wanted it to look further.

When you first open the DM, Claude offers to send you a morning briefing and an evening wrap-up every day, with a Start button. Clicking it creates a recurring task, so only click it if you need it. We didn't.

How to decide whether to switch to Team​

Why buying several seats and rotating through them yourself doesn't work, and how to keep going on API credits when you hit a limit, are covered in How to keep working when you hit Claude Code's usage limit. How I started the Team plan at a discount is in How to claim Claude Startups benefits.

FAQ (added October 28, 2026)​

These are questions I've received from small companies whose staff each used a personal Claude plan and now want to move to a team plan. I verified the Claude side against our Team organization and the official help articles. We haven't used ChatGPT Business, so that part is based only on OpenAI's official help articles as of October 28, 2026.

Should I pick Claude Team or ChatGPT Team?​

ChatGPT Team was renamed ChatGPT Business on August 29, 2025. The first thing to know is that price won't decide it. Seat prices and minimum team size are identical.

So here's the order I'd work through it in.

1. Which one is your team already used to? If people were already using their own personal Claude, Claude Team has the lowest switching cost. They can bring their existing conversations and projects into the organization (next question), and you can align team rules in one go with organization instructions (Step 5) and Skills (Step 6).
2. Do you plan to run automations through the API? This is the row where the two plans differ most. Claude Team comes with monthly API credits based on seats, while ChatGPT Business keeps the API separate from the subscription. We connect these credits to our n8n automations (Step 13). They can't be used for Claude Code, though.
3. Have you compared them on real work? Both plans allow monthly billing and start at 2 seats. Pick 3 to 5 tasks your team does every week, give the same tasks to both, and choose; that's more accurate than a feature table.
4. Are you eligible for a discount program? We were able to get a one-year discount on 5 Premium seats through Claude Startups, so we started with Claude Team. The smaller the company, the bigger that difference.

Do the personal Claude conversations and projects people were using move over to Team?​

Yes, if it's the same email. When you accept a Team invite with the same email as your personal account, a screen asks you to pick one of three options (official help article).

If you don't choose right away, a reminder banner appears for about 7 days, and you can also start later with the organization account selected via Settings > Account > Close personal account.

Once moved, it can't be undone. Chats you shared through public links also lose their links, so before moving, export your Skills, save copies of published artifacts and write down your list of connected apps.

ChatGPT Business has a similar feature. Select the Business workspace and go to Settings > Data controls > Merge personal workspace data, and conversations, custom GPTs, projects, library, scheduled tasks and memory move over. Sites don't move, and there's no undo. You can't export data yourself from a Business workspace, so OpenAI advises exporting your personal data before merging (official help article).

Do I need to cancel my personal Pro or Max subscription separately?​

It depends on which option you chose and where you paid.

We created Team while keeping a separate personal Max, so we canceled the personal Max ourselves. If the Team organization is selected at that point, the Team billing screen opens, so read the warning in Step 1 first. If you were receiving monthly API credits on personal Max, that connection ends when you move to Team, and an owner reconnects for Team credits starting 7 days after subscribing (Step 12).

Can staff who used Claude on a personal Gmail move their history too?​

The official help articles only describe moving history when the email is the same. If an employee has built up history on a personal Gmail account, you have to invite that Gmail address to Team for them to bring it over. To invite an address outside the company domain, you need to add gmail.com to the allowed domains, and turn off the invite link before that (Step 10).

If you invite their company email instead, the personal Gmail account stays separate. In that case, they start fresh on Team for company work and only need to sort out their personal subscription.

How should I split Standard and Premium seats?​

According to the official help articles, a Standard seat gets 1.25x a personal Pro plan's 5-hour usage, a Premium seat gets 6.25x, and both have separate weekly limits. Limits apply per person and can't be handed to or shared with someone else.

You can mix both seat types in one organization, so it's better to start with Premium only for heavy users and adjust after looking at actual usage in the analytics screen (Step 9).

Troubleshooting​

Who this is for​

• Instructors and training managers running their first hands-on AI session for non-developers (coding agents, no-code automation, etc.)
• Anyone who sent an install list in the pre-workshop email, only to find half the room hadn't installed anything on the day
• Workshop organizers who have to run in-person and online at the same time

All you need is your current pre-workshop email and timetable. The script in Step 2 is for Mac, and I ran it myself on macOS 26.5.1 on October 7, 2026.

First, a quick note on why I wrote this. In a 5-hour one-day workshop for college students and job seekers, initial setup alone took 2 hours, and we got through only half of the curriculum I had prepared. Most participants were seeing a coding agent, a code editor and a terminal for the first time that day. The installs themselves weren't hard. The problem was that many people got stuck at the same time, each for a different reason, and one instructor had to unblock them one by one.

Step 1. List the 8 common sticking points in your pre-workshop email​

These are the real sticking points that piled up in my instructor notes. Most of them go away with a single "that's normal," but hearing it for the first time on the day makes people freeze. So I put this table straight into the pre-workshop email.

There's almost no way to fix the last one on the day. Make it the boldest line in your pre-workshop email.

Step 2. Have participants run a check script the night before​

If you just send an install list, most people won't read it. So I added a mechanism that sends results back. The night before, participants paste the whole block below into Terminal and send a screenshot of the final screen.

cat > ~/Desktop/setup-check.sh <<'SCRIPT'
#!/bin/bash
# Pre-workshop check to run the night before (macOS)
ok(){ echo "✅ $1"; }; ng(){ echo "❌ $1"; FAIL=1; }
FAIL=0
echo "macOS $(sw_vers -productVersion)"
command -v git >/dev/null && ok "git $(git --version | awk '{print $3}')" || ng "git missing → xcode-select --install"
command -v node >/dev/null && ok "node $(node -v)" || ng "node missing → install the LTS from https://nodejs.org"
command -v npm >/dev/null && ok "npm $(npm -v)" || ng "npm missing (installed together with node)"
FREE=$(df -g ~ | awk 'NR==2{print $4}')
[ "$FREE" -ge 5 ] && ok "Free space ${FREE}GB" || ng "Free space ${FREE}GB (please free up 5GB or more)"
DIR="${1:-$HOME/ai-workshop}"
case "$DIR" in *[[:space:]]*|*[가-힣]*) ng "Work folder path contains spaces/Korean characters: $DIR";; *) mkdir -p "$DIR" && ok "Work folder $DIR";; esac
for h in registry.npmjs.org github.com; do
  curl -s -m 8 -o /dev/null "https://$h" && ok "Internet connection $h" || ng "Could not reach $h (check company network/VPN)"
done
[ $FAIL -eq 0 ] && echo "All checks passed. Please take a screenshot of this screen and send it." || echo "Fix the ❌ items, or take a screenshot of this screen and send it to the instructor."
SCRIPT
bash ~/Desktop/setup-check.sh

Here's the actual result from running it on a Mac on October 7, 2026.

macOS 26.5.1
✅ git 2.55.0
✅ node v26.7.0
✅ npm 11.19.0
✅ Free space 60GB
✅ Work folder /Users/popcorn/ai-workshop
✅ Internet connection registry.npmjs.org
✅ Internet connection github.com
All checks passed. Please take a screenshot of this screen and send it.

Adapt the checks to your own workshop. For example, if you use a coding agent, add one more command -v line to check that the tool is installed. If you only contact the people whose screenshots show a ❌ the night before, you'll have far fewer one-by-one fixes on the day.

Step 3. Lock in "everyone installs together, concepts while you wait" for the first block of the day​

Even with the night-before check, there's still installing and logging in on the day. Don't leave that time empty. I nailed down this order in my instructor notes.

People who finish early listen to the concepts, and people who are slower catch up during that time. Nobody sits around waiting for everyone's install to finish.

Step 4. Announce the watch-along mode and the minimum guaranteed outcome at the start​

I say these two sentences word for word at the start.

1. "If your install doesn't work, you're welcome to just watch. You'll get today's finished result afterward."
2. "Today's minimum goal is up to ○○. After that, it's fine if everyone finishes at a different point."

The first sentence lets stuck participants move over to watching a neighbor's screen without feeling guilty. The second splits the goal into two tiers. In that workshop, "finish a Chrome extension in 3 hours" was an aggressive goal. If I ran it again, I'd set the minimum at "load the extension into the browser and follow its structure and debugging flow."

So that stuck participants don't have to start over, save a finished version for each stage (checkpoints) in advance so they can jump straight back to the right stage.

Step 5. Make the first exercise something small that finishes within 30 minutes​

Don't dive straight into a big project. Start with something that finishes within 30 minutes, like a Pomodoro timer or a habit-tracker app, so people get used to the flow of "ask the AI for something small and check it with your own eyes." The flashy demo comes after that.

The flashier the result, the more variables there are, such as an external site's structure and browser permissions. If that site changes on the day, the whole demo falls apart, so prepare a recording and a finished version as a fallback.

When this happens, do this​

One more note on online. That day there were 13 online participants, more than in the room, but with cameras off and almost no reactions, I had no way of knowing who was stuck. My conclusion is that in a hands-on workshop, online and in-person need different ways of stepping in.

Wrap-up​

Setup time wasn't about the instructor's skill. It was a structural problem. Get results back with a night-before check script, fill the install wait on the day with concept explanations, and announce the watch-along mode and the minimum guaranteed outcome right at the start, and you'll keep far more hands-on time out of the same 5 hours.

The Cardputer ADV I brought home from the event. Turn it on and the n8n event menu comes up right away.

Who this is for​

• Anyone who got a Cardputer (or a similar ESP32 device) at a conference or meetup and isn't sure what to do with it
• Anyone touching an ESP32 board for the first time who wants to start by confirming it's properly connected to their Mac
• Event organizers wondering whether to hand out hardware as swag

You'll need the Cardputer ADV itself, a USB-C cable that supports data, and a Mac (this post is written for macOS). With a charge-only cable, the computer won't detect the device.

What is the Cardputer ADV?​

"Cardputer" means "card-sized computer" (Card + Computer). It's made by M5Stack, a development-board company in Shenzhen, China, and the ADV is an improved version released in the second half of 2025. Inside is an ESP32-S3, a microcontroller with Wi-Fi and Bluetooth. It's not a computer running an operating system like a smartphone; think of it as a device that runs one firmware image and only that program.

Specs are from the M5Stack official store. Compared with the previous model (Cardputer v1.1), the audio chip changed, and it adds a motion sensor, a headphone jack, a rear expansion header and a strap hole.

Step 1. Plug it in and identify it​

Connect it to your Mac with a USB-C cable and flip the switch on the side. Then check the USB device info in Terminal.

ioreg -p IOUSB -l -w0 | grep -E '"(USB Product Name|USB Vendor Name|idVendor|idProduct|kUSBSerialNumberString)"'

Here's what my device showed (I've removed the lines for other USB devices):

"idProduct" = 4097
"USB Product Name" = "USB JTAG_serial debug unit"
"kUSBSerialNumberString" = "70:AF:09:DF:3A:14"
"USB Vendor Name" = "Espressif"
"idVendor" = 12346

The numbers are printed in decimal, which is confusing. Converted to hex:

• idVendor 12346 = 0x303A: the USB vendor ID of Espressif, the company that makes the ESP32 chip. The device brand is M5Stack, but USB reports the chip maker's name.
• idProduct 4097 = 0x1001: the ID used by the USB port built into the ESP32-S3 (USB Serial/JTAG). It means the chip speaks USB directly, without a separate USB bridge chip.
• Serial number 70:AF:09:...: this chip's MAC address. It's different on every device.

Find the port name like this:

ls /dev/cu.*

/dev/cu.Bluetooth-Incoming-Port
/dev/cu.debug-console
/dev/cu.usbmodem1101

The one starting with cu.usbmodem is the Cardputer. The other two are ports every Mac has, so don't pick them when flashing firmware later. (If you use wireless earbuds, you may see one more port with their name.)

Step 2. Read the logs to see what the device is doing​

ESP32 firmware usually writes logs over USB serial. On a Mac you can read them briefly with cat. This command reads for 6 seconds and stops:

cat /dev/cu.usbmodem1101 & sleep 6; kill $!

My device, sitting in my office in Seoul, kept printing this:

[sdk] joining 'memento.mori'
[sdk] wifi disconnected, reason 201
[sdk] wifi disconnected, reason 201

reason 201 is an ESP32 Wi-Fi error code meaning "couldn't find the network it's trying to join (NO_AP_FOUND)". The firmware was built to auto-connect to a Wi-Fi network saved in advance at the venue, so even after leaving Berlin it keeps looking for that network. In the next step we'll switch it to your home or office Wi-Fi.

Step 3. Basic controls and changing the Wi-Fi​

The device you got at the event comes with an app loader (Cardputer Loader 0.5.5) built by n8n ambassadors. The controls are documented in the Cardputer Flasher guide. This site isn't an official n8n or M5Stack site; it's a web install page that n8n ambassador Lars Emil Christensen built for the event on his own domain. This was the URL shared at the venue.

• Use the arrow keys (; , . /) to move through menus and ok to open an app.
• Press the button on the back (BtnG0) to return to the main menu from anywhere. It works even when an app freezes. If you remember only one thing, make it this.
• esc is usually "back" too, but apps may use it for something else.

To change the Wi-Fi:

1. Open WiFi settings at the bottom of the menu. It scans nearby networks for about 6 seconds.
2. Pick a network with the arrow keys and press ok, then type the password and press ok again.
3. Press r to rescan. For hidden networks, enter the name first under Other network at the bottom of the list.
4. A black Wi-Fi icon in the top right means connected; gray with a pink slash means not connected.

Step 4. Try the three event apps​

Here's a video of me launching and using the three apps below. The small screen is magnified on the right side of the video.

The loader includes three apps, all made by n8n ambassadors for this event.

Node Quest: an RPG that teaches n8n​

A small RPG made by Greg Evseev. You walk around a village talking to people, they give you a 3-question n8n quiz, and if you get them all right you earn XP. It has 11 levels (1 tutorial plus 10 main), 50 tasks and 190 questions. You can play it all the way through offline; Wi-Fi is only used to post your score to the leaderboard.

• ; , . /: move up, left, down, right
• ok: talk to the person next to you; on the last page, start the quiz
• 1-4: choose an answer
• esc: world map

It's perfectly usable for reviewing basic concepts like "What's a trigger?" in an n8n class.

When I played it, I noticed even the area names come from n8n. Enter a portal and you can travel to places like Crossroads of If, Filter Marsh, Expression Springs, HTTP Harbor and Webhook Gate. The tutorial quiz starts with controls questions like "Which key shows the next page?" (answer: ok), and as the areas get bigger, nodes like HTTP Request come up. Holding fn while pressing an arrow key lets you dash a long way at once, which speeds up getting around the map. Quests you've already cleared don't give extra XP if you replay them.

Icebreaker: a game where your penguin grows when you meet people​

A networking game made by Fahmi Fahreza and Dominik Vogt. One person presses C to show a 4-character code, the other presses E and enters it, and both devices show a MATCHED! screen while the penguin grows one stage. Then both devices show the same icebreaker question. A code can only be used once within 60 seconds, so you actually have to be face to face.

This app syncs with the event server over Wi-Fi. I haven't confirmed whether the server is still up now that the event is over.

When you open the app, you see the penguin with a code, enter, sync and help menu on the right, and your level and number of people met at the bottom. My penguin was at LV4 thanks to a few matches at the venue. One letdown: there's no screen where you can browse the icebreaker questions that come up during matches. Once the event is over, there's no other device to match with, so you can't see any more questions.

BT mouse, keyboard and clicker: the most useful app after the event​

Made by Lars Emil Christensen, this app turns the Cardputer into a Bluetooth mouse, keyboard and presentation clicker. You don't need to install anything on the other computer.

1. Open the app and, in your computer's Bluetooth settings, pick the name shown on screen (Cardputer + 4 characters).
2. Each press of esc cycles through mouse, keyboard and clicker modes.
3. In clicker mode, any key on the left half of the keyboard goes to the previous slide and any key on the right half goes to the next. It works in PowerPoint, Keynote, Google Slides and PDF viewers.
4. Mouse mode moves the pointer as you tilt the device. Before using it, hold it the way you'll hold it and press any key to calibrate; if the pointer drifts on its own, press c to recalibrate.

Bluetooth and Wi-Fi share the same radio chip, so Wi-Fi is off while this app is running.

When I connected it to my phone, the controls worked, but it wasn't comfortable enough to use as an everyday mouse or keyboard. Think of it as a backup for when your keyboard suddenly dies; the really useful part is the presentation clicker in Step 6 below.

Open Help in the menu and it shows a QR code that leads to the usage page (cardputer.larsemil.ai/help). Scan it with your phone to open the guide I mentioned in Step 3.

Step 5. Swap the firmware or restore the event version​

The Cardputer works by replacing its firmware wholesale, so flashing another program erases the event loader. On the other hand, you can reinstall the event loader from the web anytime, so feel free to experiment.

To reinstall the event loader:

1. Go to cardputer.larsemil.ai in Chrome or Edge. It needs Web Serial, which lets the browser use USB serial, so Safari won't work.
2. Plug in the USB-C cable with the side switch turned off. Flashing runs on USB power.
3. Click Install, and in the port picker choose USB JTAG/serial debug unit (cu.usbmodem...). Don't pick cu.Bluetooth-Incoming-Port or cu.debug-console from Step 1.
4. Wait about a minute, then turn the switch back on. Don't unplug the cable while it's flashing.

If you look at the page's code, it works simply. The port picker is filtered to show only devices with Espressif's vendor ID (0x303A), and the firmware file is downloaded from the author's GitHub repo and written over the whole flash starting at address 0. The repo contains only the finished firmware files, with no source code or license published, so think of it as a way to restore the original state rather than something to modify.

According to the official M5Stack docs, there are four ways to flash other firmware (Cardputer-Adv docs).

If you want to switch between several firmware images, another option is to first install M5 Launcher, which lets you pick and run firmware from an SD card. The Flasher page also lets you download the event loader as a .bin file, so you can add it as one of Launcher's menu entries.

Step 6. Decide what to use it for after the event​

In the end, a device like this only comes out of the drawer once you've decided what it's for. Here's where I think it's useful right away:

1. A clicker for teaching: exactly the clicker mode from Step 4. Any key on either half of the keyboard works, so it's easy to advance slides without looking.
2. An n8n webhook button: an ESP32 on Wi-Fi can send HTTP requests, so you can build firmware that calls an n8n webhook with one keypress. It's a good fit for one-button workflows like "clock in" or "meeting started" alerts. I'll verify how to build it and write it up separately.
3. A sensor hub: plug a temperature/humidity or fine-dust sensor into the Grove port and send the readings to n8n, and you've got a small IoT project. I've written up how to combine ESP32 and n8n in An IoT automation portfolio with ESP32 and n8n.

A quick thought: why do overseas conferences hand out hardware?​

At developer conferences outside Korea, you get devices like this fairly often. The one I remember is the GitHub Universe badge. In 2023 they gave out an RP2040-based e-ink badge made with Pimoroni, and in 2024 a version with the chip upgraded to the RP2350. Both were name badges that were also boards you could program in MicroPython. But I hardly remember ever getting something like that at a conference in Korea.

Thinking about why, I see two reasons overlapping:

• Cost: the Cardputer ADV retails for around $30, and In The Loop had up to 1,200 people. A simple calculation puts that in the tens of millions of won. On top of that, importing hundreds of devices with Wi-Fi and Bluetooth to hand out means dealing with Korea's radio certification (KC conformity assessment) or an exemption process.
• Usefulness: I think this is the bigger reason. If you just hand out devices, most of them go home and end up in a drawer.

What made this n8n event different was the software more than the device. Four ambassadors built the event loader and three apps, so at the venue you could learn the product with Node Quest and meet people with Icebreaker, and afterwards use it as a presentation clicker. I think the key to hardware swag isn't the cost of the device but designing "a reason to pull this out during the event" along with it. Events in Korea could start by attaching one such reason to the phones or badges people already have, instead of an expensive device.

Troubleshooting​

The question I get most in corporate training isn't about features. It's "Am I allowed to put this in?" People practice with made-up data, then hands go up at "So can I do this with our real company files?", followed by "What if I put it in and it causes a problem?" Without a guideline, everyone has to judge for themselves and take the blame alone, so the rational choice becomes not using it at all. The 5 steps below are a way to make that guideline concrete.

Who this is for​

• You want to handle work emails and reports with AI but have stalled because you don't know how much you can put in
• You're a team lead or leader who needs to set a "never put this into AI" rule for your team
• You're in charge of training and need to give employees input guidelines

Here's what you need.

1. A ChatGPT or Claude account
2. To follow Steps 3 and 5, a computer with Python 3 installed. On a Mac, check with python3 --version in the terminal. No extra packages are needed.
3. Your company's AI usage policy, if it already has one. Your company's policy takes priority over this post.

Step 1. Check whether your account uses your chats for training​

The first thing to do is check your settings. Personal plans and company plans have different defaults. I confirmed the details below in each company's official help docs on October 7, 2026.

If you're on a personal account, check the setting yourself.

• ChatGPT: Profile menu → Settings → Data controls → turn off Improve the model for everyone. The mobile app has the same menu.
• Claude: In Settings, turn off the toggle for model improvement (labeled Help improve our AI models in the official help docs). The direct link to the privacy settings is claude.ai/settings/data-privacy-controls.

Two things to know before moving on.

• Even with training turned off, your chats are still stored on the company's servers. The training setting only decides "is it used for training." That's why the masking in Steps 2-3 is still needed.
• Clicking 👍 or 👎 feedback sends the entire chat. OpenAI says it may use chats you gave feedback on for training, and Anthropic says it keeps feedback chats for up to 5 years. Don't click the feedback buttons in chats that contain company data.

Step 2. Share a 4-line "what we don't put in" list with your team​

Long lists don't get followed. The items change with every situation, and when something comes up that isn't on the list, people stall again. Give one rule, and attach an alternative only to the 4 items people run into most. You can paste the block below into your team channel as is.

[AI input guideline]
Rule: If you couldn't send it to someone outside the company by email, don't put it into AI.

1. Real names and contact details of customers and partners → replace with aliases like [ClientA], [ContactA]
2. Contract amounts, unit prices, quotes                  → mask as [Amount1] or swap in example numbers
3. Unreleased technical info, drawings, yields            → don't put in (not even a summary)
4. National ID numbers, accounts, passwords               → never put in, under any circumstances
* A person clicks the send button. AI only does translation and drafts.

The key is that items 1 and 2 come with alternatives. When I gave only the forbidden items in a lecture, students nodded along and then finished the exercise without using any real material at all. Only after I gave them the alternatives too did I hear "Oh, so I can just do it this way."

When an item comes up that people disagree on (a person's job title in meeting notes, someone's schedule, and so on), don't add more items; go back to the one-line rule: Could I put this sentence in an email to someone outside the company as is?

Step 3. Create a file with the values masked​

What AI needs to write a draft reply is the structure, not the values. What matters is what the other party asked for and by when; their company's real name doesn't make the draft any better.

You can delete things by hand, but if you do it often, a script is easier. The mask.py below automatically finds and masks email addresses, mobile numbers and amounts, and replaces only the company and person names you list at the top.

import re, sys, json

# Names to mask: regex can't find company, person or product names, so list them yourself.
NAMES = {
    "Hanbit Trading": "[ClientA]",
    "Kevin Park": "[ContactA]",
    "한빛무역": "[ClientA]",  # the same company written in Korean
}

PATTERNS = [
    ("Email", r"[\w.+-]+@[\w-]+\.[\w.-]+"),
    ("Phone", r"(?:\+82[- ]?|0)1[016789][- ]?\d{3,4}[- ]?\d{4}"),
    ("Amount", r"(?:USD|\$|₩)\s?\d[\d,]*(?:\.\d+)?|\d[\d,]*(?:\.\d+)?\s?(?:원|만원|억원|달러)"),
]

def mask(text):
    found = []
    for real, alias in NAMES.items():
        if real in text:
            found.append((alias, real))
            text = text.replace(real, alias)
    for label, pat in PATTERNS:
        n = 0
        def repl(m):
            nonlocal n
            n += 1
            tag = f"[{label}{n}]"
            found.append((tag, m.group(0)))
            return tag
        text = re.sub(pat, repl, text)
    return text, found

if __name__ == "__main__":
    src = sys.argv[1]
    text = open(src, encoding="utf-8").read()
    masked, found = mask(text)
    out = src.rsplit(".", 1)[0] + "_masked.txt"
    open(out, "w", encoding="utf-8").write(masked)
    # The table of original values stays only on your computer. Never put it into AI.
    keyfile = src.rsplit(".", 1)[0] + "_key.json"
    json.dump(dict(found), open(keyfile, "w", encoding="utf-8"), ensure_ascii=False, indent=2)
    print(f"Masked {len(found)} items → {out}")
    print(f"Key table → {keyfile} (do not put this into AI)")

Save the email body as sample_email.txt and run the script in the same folder.

python3 mask.py sample_email.txt

Here's the actual output from running it on a made-up English email.

Masked 6 items → sample_email_masked.txt
Key table → sample_email_key.json (do not put this into AI)

Notice in the result that the quantity 2,000 units and the delivery date November 20 were left as is. The script only finds the patterns you've defined. Values whose sensitivity varies by company, like quantities, dates and project code names, should be added to the NAMES list or deleted by hand. Step 3 isn't done until you've read the _masked.txt file once with your own eyes after running the script.

Step 4. Get both a draft and a review list from AI using the masked file​

Now put only sample_email_masked.txt into AI. Never put in _key.json. The trick is not to ask only for the output, but to also get a list of things a person needs to check.

The attached file is an English email from an overseas partner.
Parts in square brackets like [ClientA] and [Amount1] are values I masked on purpose, so leave them as they are.
1) A summary in my language
2) A list of what the other party is asking for
3) Blanks and facts I need to check myself
4) A polite draft reply in English (use the masked values in brackets as they are)
5) A pre-send review checklist (including whether every masked value has been filled in and no sensitive information remains)

Items 3 and 5 are the key. Because you masked the input, the draft will have blanks, and the AI gives you a list of where they are. No more "I need to fill that in later, but where was it?"

If you use a tool that reads files in a folder, like Claude Code, keep the original and the masked version in separate folders and work only in the masked folder. What you let the AI read then stays visible in the state of the folders, so you can check it later.

Step 5. Restore the blanks in the draft to the original values, and have a person send it​

Save the AI's draft reply as reply_draft.txt, then use the script below to replace the brackets with the original values. This happens only on your own computer.

import json, sys
draft, keyfile = sys.argv[1], sys.argv[2]
text = open(draft, encoding="utf-8").read()
table = json.load(open(keyfile, encoding="utf-8"))
for tag, real in table.items():
    text = text.replace(tag, real)
out = draft.rsplit(".", 1)[0] + "_restored.txt"
open(out, "w", encoding="utf-8").write(text)
print(f"Restored → {out}")

python3 unmask.py reply_draft.txt sample_email_key.json

Here's the result from running it on two draft sentences containing brackets.

Restored → reply_draft_restored.txt

Dear Kevin Park,

Thank you for your order from Hanbit Trading. We confirm the unit price of USD 14.50 (total $29,000).

Finally, go through the review checklist from Step 4 to check the numbers, dates and names, and a person clicks the send button. AI handles only translation and drafts.

If you hit an error, check here first​

Wrap-up​

• The rule is one line: if you couldn't send it to someone outside the company by email, don't put it into AI.
• Even with training turned off, your chats are stored, so keep masking values before you put them in.
• Mask → get a draft and a review list from AI → restore on your own computer → a person sends it.
• A leader's job is less about adopting tools and more about announcing these 4 lines to the team. People can use AI without fear of getting in trouble only when the guideline exists in writing.

References​

Official documentation checked on October 7, 2026.

• OpenAI Data Controls FAQ
• OpenAI Enterprise privacy
• Anthropic: Is my data used for model training? (personal plans)
• Anthropic: How do I change my model improvement privacy settings?
• Anthropic: Is my data used for model training? (commercial products)

Who this is for​

• You use Claude Code on Claude Team (Standard or Premium) or Max and hit the limit often
• You're worried that API credits from a startup program or promotion will expire unused
• You're wondering, "Can't I just rotate through several Team seats myself?" (I'll explain below why that doesn't work)

Here's what you need.

• macOS Terminal (zsh) and Claude Code installed. I tested on version 2.1.302
• A Claude Console organization that holds credits
• A password manager to store the key (optional)

First: rotating through multiple seats is not allowed​

You'll often see tricks shared for "automatically switching to the next account when one runs out of usage." A typical case is one person using 5 Team seats. But the official help page states clearly that each seat is assigned to one designated person and only that person can use it, and routing work through someone else's account to use their remaining usage isn't allowed either (Purchase and manage seats on Team plans). If you need more, it tells you to upgrade to a Premium seat or turn on usage credits.

Startup program benefits only last as long as you follow the terms, so if you get caught rotating accounts, you could lose your Team discount and your credits along with it. The method in this post is the same person using their own API key, so this issue doesn't apply.

Step 1. Check your credit balance and auto-reload status​

Open Claude Console > Billing. First, check in the top right that the organization holding your credits is selected.

There are two things to look at.

• The balance and expiry date in the promotional credits table. In my case it's $1,000, expiring April 5, 2027 (UTC). The $999.99 in the screenshot above is after I spent 1 cent on the tests in this post.
• "Auto-reload is off. API requests will stop when your balance runs out." If you see this, using up your credits won't charge your card; requests just stop. If you only want to spend within your credits, leave it off.

Step 2. Create an API key just for Claude Code​

In Console > API keys, click Create key. If an identity federation notice appears first, click Continue with API key.

When you click Create key, the key is shown only once. Click Copy key and save it in your password manager first. Once you close the dialog, you can't see it again.

Step 3. Save the key in a file only you can read​

Run the following in Terminal. read -rs doesn't echo what you type, so after running it, paste the key you copied and press Enter.

mkdir -p ~/.config/claude-api && chmod 700 ~/.config/claude-api
read -rs KEY && printf '%s' "$KEY" > ~/.config/claude-api/key && chmod 600 ~/.config/claude-api/key && unset KEY
ls -l ~/.config/claude-api/key   # -rw------- means it's correct

The reason not to put the key in .zshrc as export ANTHROPIC_API_KEY=... is that your regular claude would then always run on the API key too, and credits would get used up before your Team or Max usage. The key is only loaded when you run the command below.

Step 4. Create the claude-api command​

Create an executable in the folder where Claude Code is installed (~/.local/bin). If which claude shows a different path, change the path on the last line to match.

cat > ~/.local/bin/claude-api <<'EOF'
#!/bin/zsh
# Runs Claude Code with the Console API key (credits).
KEY_FILE="$HOME/.config/claude-api/key"
if [[ ! -r "$KEY_FILE" ]]; then
  echo "API key file not found: $KEY_FILE" >&2
  exit 1
fi
export ANTHROPIC_API_KEY="$(<"$KEY_FILE")"
exec "$HOME/.local/bin/claude" "$@"
EOF
chmod 755 ~/.local/bin/claude-api

Since it doesn't touch .zshrc, there's no conflict even if you manage your dotfiles with git. The command sets ANTHROPIC_API_KEY for that run only and passes every other option straight through to claude.

Step 5. Confirm it's actually billing your credits​

I checked three things.

1) Whether you get a response

claude-api -p "Reply with exactly: OK" --model haiku
# OK

2) Whether the key is used instead of the logged-in account. If you deliberately pass a wrong key, it should fail.

ANTHROPIC_API_KEY=sk-ant-invalid-test claude -p "Reply OK" --model haiku
# Invalid API key · Fix external API key

This means the key in the environment variable takes priority over your login, so requests run through claude-api are deducted from your credits. Sure enough, after testing, my Console balance went from $1,000.00 to $999.99 (the Step 1 screenshot).

3) Whether it continues the previous conversation

claude-api -p "Remember this word: PINEAPPLE. Reply only: saved" --model haiku
# saved
claude-api -c -p "What word did I ask you to remember? Reply with the word only." --model haiku
# PINEAPPLE

Claude Code stores conversation history on your computer (per project folder), so adding -c in the same folder continues the previous conversation even when the authentication method changes.

How to use it​

Credits disappear when they expire. In my case I need to spend $1,000 over about 5.5 months, which works out to a pace of roughly $180 a month. If I only used it when I hit the limit, I'd likely have credits left over, so I run long jobs like big refactors or batch work on claude-api from the start. I also set a reminder on the 1st of every month to check my balance and last month's spend.

If you moved from Max to Team: cancel your personal subscription​

Starting Team doesn't automatically cancel your existing personal Max subscription. In claude.ai, open the account menu at the bottom left, switch to your personal account (for example, "Personal Max"), then go to Settings > Billing > Cancel subscription > Cancel. If you open billing settings with the Team organization selected, you get the Team organization's billing page, and it also has a Cancel button. Clicking it there cancels Team, so first check that the page title says "Max plan."

Once you cancel, it changes to "Your subscription will be canceled on [date]," and you can keep using Max until then. If you change your mind, use Resubscribe to undo it. As long as you don't delete the account itself, your existing conversations and projects stay.

Troubleshooting​

Wrap-up​

To sum up, you create one key in the Console and add one file plus one executable, and you're done. You use your seat limit as your seat limit and continue overflow work on your own credits, so there's no worry about getting into trouble by rotating accounts. I'll follow up after a month with how fast the credits actually go down.

Who this is for​

• You make subtitles often and API costs or paid captioning services are adding up
• You want subtitles for videos you'd rather not upload to an outside service, like lecture or meeting recordings
• You can copy and paste commands into a Terminal window (you don't need to know how to code)

If you'd rather just tell an AI coding tool "make subtitles for this," see Part 1: Drop a video into Codex and say "make subtitles". Part 1 uses the OpenAI API, so you pay for what you use and your audio is sent to OpenAI. This post takes the other route: your own computer does the work.

A few terms first​

• Whisper: A speech recognition model released by OpenAI. Once you download the model files, you can run it on your own computer without the API.
• faster-whisper: A free program that runs Whisper faster and with less memory. This is what we'll install.
• SRT: A subtitle file format. It's a plain text file listing "this sentence, from second X to second Y," so you can load it straight into Premiere, CapCut, DaVinci Resolve or YouTube.

What you need​

You don't need to install a separate video converter like ffmpeg. faster-whisper reads the audio directly from mp4 files. I didn't test Windows or NVIDIA GPU setups, so this post doesn't cover them.

Step 1. Open Terminal and check your Python version​

1. Press Command + Space to open Spotlight, type Terminal, and open it.
2. Paste the command below and press Enter.

python3 --version

If you see Python 3.10 or later (3.11, 3.12, 3.13, etc.), move on. If the number is 3.9 or lower, or you get command not found, download the latest macOS installer from the python.org downloads page, install it, then close and reopen Terminal and check again.

Step 2. Create a working folder and a virtual environment​

A virtual environment is a box that holds only the programs this project needs. It doesn't mix with other Python programs on your computer, and if you ever want to remove it, you just delete the folder.

mkdir -p ~/Desktop/local-subtitles
cd ~/Desktop/local-subtitles
python3 -m venv .venv
source .venv/bin/activate

After the last line runs, (.venv) appears at the start of your Terminal prompt. You need to see this so the next step installs into the box. Whenever you open a new Terminal window, run cd ~/Desktop/local-subtitles and source .venv/bin/activate again.

Step 3. Install faster-whisper​

pip install faster-whisper "av<19"

Check that the install finished with this command.

pip show faster-whisper av

You should see two versions, like Version: 1.2.1 (faster-whisper) and Version: 18.1.0 (av).

There's a reason for adding "av<19". av is the component that pulls the audio out of a video. As of October 2026, running just pip install faster-whisper also installs the latest av 19. But faster-whisper 1.2.1 isn't compatible with av 19, and you get TypeError: open() got an unexpected keyword argument 'metadata_errors' the moment you run it. Pinning av to version 18 makes it work. This pin may become unnecessary once faster-whisper is updated.

Step 4. Create the subtitle script​

The block below creates a script called make_srt.py in your working folder. It takes a video file and saves a .srt file with the same name. Copy the whole thing at once, from the first line cat > to the last line EOF, paste it into Terminal, and press Enter. You don't need to change any code.

cat > make_srt.py <<'EOF'
import argparse
from pathlib import Path

from faster_whisper import WhisperModel


def to_srt_time(seconds: float) -> str:
    ms = int(round(seconds * 1000))
    h, ms = divmod(ms, 3_600_000)
    m, ms = divmod(ms, 60_000)
    s, ms = divmod(ms, 1000)
    return f"{h:02}:{m:02}:{s:02},{ms:03}"


parser = argparse.ArgumentParser(description="Turns a video or audio file into SRT subtitles.")
parser.add_argument("file", help="Video or audio file to subtitle")
parser.add_argument("--model", default="small", help="tiny, base, small, medium, large-v3")
parser.add_argument("--device", default="cpu", help="cpu or cuda")
parser.add_argument("--compute-type", default="int8", help="int8 for cpu, float16 for cuda")
parser.add_argument("--language", default="ko")
args = parser.parse_args()

model = WhisperModel(args.model, device=args.device, compute_type=args.compute_type)
segments, info = model.transcribe(args.file, language=args.language, vad_filter=True)

out_path = Path(args.file).with_suffix(".srt")
with open(out_path, "w", encoding="utf-8") as f:
    for i, seg in enumerate(segments, start=1):
        f.write(f"{i}\n{to_srt_time(seg.start)} --> {to_srt_time(seg.end)}\n{seg.text.strip()}\n\n")
        print(f"[{to_srt_time(seg.start)}] {seg.text.strip()}")

print(f"Done: {out_path}")
EOF

To check that it was created correctly, run the command below. If you see the usage message, you're set.

python make_srt.py --help

usage: make_srt.py [-h] [--model MODEL] [--device DEVICE]
                   [--compute-type COMPUTE_TYPE] [--language LANGUAGE]
                   file

Turns a video or audio file into SRT subtitles.

Step 5. Add a video and run it​

1. In Finder, move the video you want to subtitle (for example, my-video.mp4) into the local-subtitles folder on your Desktop. File names without spaces are easier to type.
2. Enter the command below in Terminal.

python make_srt.py my-video.mp4

The first time, it takes a few minutes to download the speech recognition model (small, about 480MB). The model is saved in ~/.cache/huggingface, and it won't download again after that.

While it runs, each recognized sentence prints on screen, one line at a time. Here's the real output from a 25-second Korean test video (the script defaults to Korean; I've translated the transcript into English).

[00:00:00,000] Hi, this is Data Popcorn.
[00:00:04,040] Today we'll look at how to make video subtitles for free on your own computer.
[00:00:11,400] The subtitle file gets created without uploading the audio to the internet.
[00:00:18,040] First, file line, create a virtual environment and install the packages.
Done: my-video.srt

With the model already downloaded, my M3 MacBook took about 21 seconds to process this 25-second video. Times vary with video length and hardware, so for long videos I recommend trying a 1 to 2 minute clip first.

Changing options​

To change the model size, add the name after --model (for example, --model medium). Models get bigger in this order: tiny, base, small, medium, large-v3. Bigger models are more likely to be accurate, but the download and processing time grow too. The only model I actually ran for this post is small, so I suggest going all the way through with small first and only moving up if the results fall short.

Step 6. Open the SRT file and fix mistakes​

A my-video.srt file with the same name as your video appears in the folder. Open it in a text editor and it looks like this (transcript translated from Korean).

1
00:00:00,000 --> 00:00:04,040
Hi, this is Data Popcorn.

2
00:00:04,040 --> 00:00:11,400
Today we'll look at how to make video subtitles for free on your own computer.

The transcription isn't perfect. In the test above, "Python virtual environment" (파이썬 가상환경) came out as "file line, virtual environment" (파일 선, 가상환경). Always check these three things by eye:

• Product names, people's names and technical terms (these get it wrong most often, like "Python" above)
• Spacing in company names ("데이터팝콘", DataPopcorn, came out as two words, "데이터 팝콘")
• Numbers and units

Leave the timing lines (the ones with -->) alone, fix only the text lines, and save. How to bring the corrected SRT into your editing tool is covered in Part 1, "Importing the generated subtitles (SRT) into your editor".

If you get an error, check here first​

Wrap-up​

Check Python → create a virtual environment → pip install faster-whisper "av<19" → paste the script → python make_srt.py <video-file> → review the SRT. Those six steps give you a subtitle file on your Mac at no cost. You only install once; after that, you drop a video into the folder and run the single command from Step 5. The trade-off: processing takes as long as your computer needs, and just like the API route, a human still has to review the transcript once.

Ask an AI to "analyze this data" and you get tables and charts within minutes. The problem is that the results look plausible even when they're wrong. And when the number is big, like "+124% growth," people actually stop questioning it. A big number feels like evidence in itself.

Every example number in this post is one I calculated myself from public data anyone can download (World Bank, Wikipedia page views).

Who this is for​

• You've given ChatGPT, Claude or Gemini an Excel or CSV file and asked it to analyze it
• You're a leader or planner who has to review and sign off on "up ○○%" reports from teammates or AI
• You're a job seeker building a data analysis portfolio and worried "Will this conclusion get torn apart in an interview?"

You need two things.

1. One analysis result produced by AI (a sentence, table or chart, anything works)
2. The AI chat window that produced it (you'll ask it to recalculate in the same window)

You don't need any statistics background. Every concept is explained from scratch at the step where it's needed.

Step 1. Pull out only the "number sentences" and write down what each compares against​

Before reading the whole analysis, pull out just the sentences that contain numbers. Then next to each sentence, write "what is this number compared against?"

If there's a sentence where you can't write down a baseline, that's the first problem. Ask the AI chat window:

For every sentence in your result that contains a % change, make a table showing what (period and target) it was compared against.
Flag any sentence whose baseline isn't in the data.

This table is the starting point for the steps that follow.

Step 2. Check whether the baseline period was an "abnormal time"​

A rate of change is "current value ÷ baseline value − 1." If the baseline (the denominator) is abnormally small, the rate of change gets big automatically. So when you set the baseline decides half the conclusion.

Let's calculate with real data: the number of domestic and international passengers carried in a year by Korean-registered airlines, published by the World Bank (indicator code IS.AIR.PSGR).

It's the same 2023 number, but the conclusion changes depending on the baseline.

• vs. 2020: +154.0%
• vs. 2021: +124.2%
• vs. 2019: −17.5%

"Air passengers surge 124%" and "still 17.5% below pre-COVID levels" are both correct numbers. In 2020-2021, COVID had nearly shut down air travel, so using those years as the baseline makes a recovery read like growth.

Checking takes three lines.

1. Find the baseline period in your Step 1 table.
2. Check whether anything unusual happened then: COVID, a disaster, a policy change, a major holiday.
3. If so, have it recalculate using a normal period as the baseline.

Recalculate the same rate of change using 2019 (or a year with no special events) as the baseline.
Show both results side by side and tell me in one line whether the conclusion changes.

Step 3. Check whether it compared single points, then widen the range and recalculate​

A sample is the slice of data used to reach a conclusion. If you compare one day against one day, like "first Saturday of March vs. first Saturday of April," your sample is just two points. The number swings a lot depending on whether it rained or whether it was a public holiday.

I calculated this myself using the daily page views of the Korean Wikipedia article on Busan (부산광역시) for March-April 2025.

Depending on which Saturday you pick, you get −19% or −46%, and if you look at the whole month, the direction flips to an increase. On top of that, March 1 was Samiljeol (Independence Movement Day), a public holiday in Korea. A special day was hiding inside the ordinary-looking baseline of "first Saturday."

Check in this order.

1. Count how many dates (or records) the comparison used. If it's one or two, widen it.
2. Recalculate using the overall average or total for the same period.
3. See whether the direction of the result (increase/decrease) holds. If the direction changes, don't use the original conclusion.

Tell me how many dates you just used in the comparison.
Recalculate using the daily average for the whole period, and flag any public holidays or long weekends mixed in.
Also tell me whether the direction of the conclusion changes.

One more thing to check. With data where the absolute numbers are small, like around 200 page views a day, a difference of a few dozen in a day moves the rate of change by tens of percent. A big percentage change on a small number is more likely noise than signal.

Step 4. Check whether "what was counted" matches the question​

If the AI counted data by keyword or name, check that the words aren't mixed up with other meanings. Keyword counts count letters, not meaning.

For example, the Korean keyword "동해 여행" (Donghae travel) mixes trips to Donghae City in Gangwon Province with trips to the East Sea (also called 동해 in Korean). You want to analyze the city, but you end up counting seaside posts too. If you narrow it to "동해시 여행" (Donghae City travel), you miss posts that left out "City" and undercount. In cases like this, rather than committing to a single number, it's more honest to report a range: "narrow count to broad count."

At this step, check two more things.

• Official name vs. everyday name: If the name people actually search for ("Jeju-do") differs from the official administrative name ("Jeju Special Self-Governing Province"), check both.
• Adjusting for population and size: "It happened most in Seoul" may just be because Seoul has the most people. Look at values divided by size as well, such as per capita or per 10,000 people.

Check whether the keywords or names counted in this analysis could be mixed up with other meanings (homonyms, common nouns).
If they could, count them with a narrow and a broad definition and show the result as a range.
If this compares regions or groups, also calculate values divided by population or size.

Step 5. Check whether the place the data came from (the source) leans a certain way​

Source bias is a skew that comes from where the data was collected. If you analyze a neighborhood by collecting blog posts, "cafés" can easily come out on top. Not because the neighborhood is famous for cafés, but because blogs as a medium are full of café posts to begin with.

There's one way to check: apply the same criteria to other targets. If cafés come out on top in every other neighborhood too, that's a trait of the source, not of the target. Comparing targets of similar size cancels out the shared bias and leaves only the real difference.

Source bias can also create things that "aren't there." Blogs and reviews are full of praise, and complaints get posted less often. Even if the result says "almost no complaints about parking," that might not be because parking is easy, but because the source is one where those posts rarely appear.

Check whether the item that came out on top in this result reflects a general tendency of the data source (medium).
Suggest a way to check whether the same item still comes out on top when the same criteria are applied to 3 comparison targets.
Also point out whether results where something shows up rarely, like "no complaints," could be due to the nature of the source.

Step 6. If you see "because," ask three causal questions​

If the AI's result says things like "thanks to the opening" or "due to the campaign," stop. Overlapping timing alone doesn't let you call something a cause. Check these three things.

1. Trend before the intervention: Was it already rising before that event? If it was flat and then turned at that moment, it's more likely to be a cause.
2. Comparison with other places: Did other places where the event didn't happen rise just as much in the same period? If so, the cause may be a shared factor like the season or the economy.
3. The link in between: Can you confirm the intermediate steps with data, as in "opening → shorter travel time → inflow of a specific age group"?

Find the sentences in this result that assert a cause.
For each sentence, make a table showing whether (1) the trend before the intervention, (2) a comparison target with no intervention and (3) the intermediate link
were confirmed with data, and rewrite any sentence you couldn't confirm to the level of "is associated with."

Step 7. Run the remaining pitfalls all at once with a review prompt​

Steps 1-6 cover the most common pitfalls. To check the rest without missing anything, paste the prompt below as is into the chat window where the analysis was done.

Review the analysis you just produced against the 15 criteria below.
For each item, judge it as one of [No issue / Suspicious / Can't verify],
and if it's Suspicious, write the reason and a way to recalculate in one line.
At the end, split the conclusion sentences into ones that can be used as is and ones that need fixing.

1. Unit: Did you count by the name people actually use, not just the official administrative name?
2. Homonyms: Could the keyword be mixed up with a common noun or another meaning?
3. Mentions ≠ destination: Did you claim something is a "place people want to go" just because it's mentioned a lot?
4. Baseline period: Did you use an abnormal time, like COVID, a disaster or a holiday, as the baseline?
5. Size adjustment: Did you compare absolute values without adjusting for differences in population or size?
6. Absolute value vs. rate of change: Did you use the metric that fits whether the question is about "big places" or "rising places"?
7. Sample noise: Is this a single-point comparison, like one day or one record? Does it hold when you widen the range?
8. Small numbers: Did you read a big rate of change on data with small absolute numbers as a signal?
9. Source genre bias: Did you read an item the source medium naturally covers a lot as a trait of the target?
10. Source positivity bias: Did you conclude there are "no" complaints or problems from a source that is mostly praise?
11. Causation: Did you assert a cause just because the timing overlapped?
12. Recurring events: Did you treat a festival or season that repeats every year as the cause of a change unique to this year?
13. Interest ≠ action: Did you treat search volume or social media mentions as the same as actual visits or purchases?
14. Data scope: Did you check the collection period and any cap on the number of records?
15. Reader's perspective: Did you present something everyone already knows as if it were a new finding?

On October 7, 2026, I deliberately wrote three wrong analysis sentences using this post's numbers and ran this prompt once. They were: "It surged 124.2% vs. 2021, so demand for overseas travel has exploded," "Comparing first Saturdays, it fell 19.3%, so interest has cooled," and "It's because the cherry blossom festival ended" (Codex CLI, gpt-5.5 model).

It caught the baseline period, the single-point comparison and the causal assertion, but missed what was counted (that the metric includes domestic flights) and the special day on the calendar. Both are things you only notice by looking at the data definition and the calendar yourself. This was a single run, so results may differ with other models or other analyses. That's why, even when the AI says "No issue," a person still checks Steps 1-6 directly.

Items the AI marks "Suspicious" go back through the recalculation prompts in Steps 2-6. But for source bias (items 9 and 10) and causation (item 11), a person takes one more look even when the AI says "No issue," because judging them requires context from outside the data.

Many people try to check all 15 from the start and never finish the analysis. If you're short on time, treat only three as mandatory: baseline period (item 4), sample (item 7) and unit (item 1). Running the rest before you submit the report is enough.

If you get this result, do this​

Wrap-up​

• The bigger the number, the sooner you write down "compared against what?"
• The baseline period, the sample and the unit counted can change even the direction of the conclusion. For air passengers, just changing the baseline gave both +124% and −17.5%, and for page views of the Busan article, just changing the compared dates flipped a decline into an increase.
• Use AI as a tool that redoes calculations quickly, and leave the final call on source bias and causation to a person.

Automation is closer to "AI processes it fast and a person questions it" than "AI does it all." The review prompt above packages that questioning into a reusable form so you don't have to do it from scratch every time.

Watch on YouTube

What we wanted to test with the dino game was whether decisions arrive in time​

In a game, you have to pick the next move while an obstacle is approaching, so response latency is something you can actually see. At first, having the AI look at the screen and pick everything down to the jump timing was hard. So we started from the public Jev dino game code and split state reporting from execution.

In this experiment, the AI doesn't get a screenshot. The game code reads the obstacle type, count and height and the current speed and passes them on, and the model picks one of jump, duck or keep running, plus a jump type. The code takes that choice and calculates when to actually press the keys.

For example, when an obstacle approaches, the AI chooses whether to jump. When to press the key and how long to hold it is up to the shared control code. Since the AI isn't pressing keys every frame, how well the game goes depends on both the model and the control code.

We gave three models the same state and options​

We specified Jev 1.13, Claude Haiku 4.5 and GPT-5.4 Mini. Claude and GPT returned one of the fixed options via function calling through OpenRouter's Chat Completions, and Jev used the choice questions in the Decisions API. We used the same state, question and options in meaning, but converted the API format to fit each model.

We built the connection in this order: reading game state, a per-model API adapter, then shared control code. First we checked that state and actions made the round trip with one model, then changed the others to return the same options. API keys were read on the server, not put in the browser.

Below are the core requirements to use when having an AI coding tool write the connection code. For exact API endpoints and response formats, check the TypeSafe docs, the OpenRouter docs and the official GPT-5.4 Mini docs.

Read the obstacle state from the public dino game code and send it to the API.
The model chooses jump / duck / keep_running and a short / full jump.
Have the shared code calculate the jump timing from the current speed.
Even if the dino is mid-jump at the first observation, don't assume it stays that way until the obstacle arrives.
Only allow a short jump for a single small cactus.
Record and replay the same obstacle types, counts, heights, gaps and speed adjustments.
Don't pause the game while waiting for the API; run it at the original speed settings.
Log API errors separately from crashes, and don't use fallback actions or mock responses.
End the test at 60 seconds of real time and log response time, cost, model name and failure reasons.

We turned reasoning off for Claude and GPT and set temperature 0 with a 128-token output limit. We didn't use automatic retries, response caching or fallback actions that hide API failures. We also didn't change whether to act based on Jev's confidence number.

The same seed wasn't enough, so we fixed the obstacle course itself​

At first we thought the same random seed would make for a fair comparison. But the order in which random numbers get consumed at runtime sometimes changed obstacle gaps or types, so we recorded the properties of the course that was actually generated and replayed it for the other models. All three models in this recording met the same first obstacle, 3 small cacti, and we confirmed that the generated obstacle records matched the reference course.

Game settings were base speed 6, acceleration 0.001 and max speed 13. Runs took place in real time in the browser, and the game didn't pause while waiting for the API. The original game's acceleration depends on frame count, so the results can't be generalized to other computers or browsers.

For the Reel, we picked each model's longest-surviving recording​

In the first edit, Haiku ended at the first obstacle, so its part of the comparison was too short. Past experiments had a run in the 14-second range, but no video of it survived, so we recorded additional real API play on the same course with the same questions and control code. We didn't change the game speed or obstacle rules, or stretch the footage to make anything look like it lasted longer.

The valid recordings were 7 runs for Haiku, 7 for GPT Mini and 4 for Jev. Haiku and GPT each include 4 runs on default routing and 3 on OpenRouter's latency-first routing. Routing is the setting that decides which provider's server an API request goes to. All 4 Jev runs survived until the test ended at 60 seconds of real time. The total cost recorded in the API responses across all 18 valid runs, including the first recording, was $0.047368706.

The selected Haiku run used provider.sort: latency, and the GPT Mini run used default routing. According to OpenRouter's official docs, this setting asks to prioritize low-latency providers; it doesn't guarantee response time across a whole game. Jev used its dedicated Decisions API.

The Reel is a highlight showing the best recorded play. Each model had a different number of attempts and the routing was mixed, so don't read it as a fair win-rate or average-latency comparison or a universal performance ranking. Call costs also differ with play length and call count, so we don't calculate savings on the same task from the totals alone.

Round 2 ran decision-only APIs against each other for up to 5 minutes​

After the first comparison, we compared APIs that return a choice instead of general-purpose models. We connected Jev, OpenAI Decisions (GPT-6 Luna Decisions), MS Decision-1 and Clef Flash to the same obstacle course and control code, and ran each model 5 times for up to 5 minutes of real time. MS was recorded separately under the same conditions after the other three. Solar, originally included, was left out of the comparison in this Reel.

The Reel shows each model's longest-surviving run. Jev and OpenAI Decisions both made it to the 5-minute cap without crashing. That means both models survived to the end in their best run of this test. Across all 5 runs, Jev reached the cap twice and OpenAI Decisions once; MS and Clef never did. This doesn't establish accuracy on business tasks or superiority across all games.

Solar wasn't so much wrong as late​

At first we also connected Solar Decide to the same game. All 5 valid runs crashed into the first obstacle at about 4.48 to 4.49 seconds of game time. But when we checked the API responses, it had chosen jump, full jump all five times. That was the right choice for clearing 3 small cacti, but the responses took 5.19 to 8.85 seconds, with a median of 6.07 seconds. The game doesn't pause while waiting for the API, so by the time the answer arrived, the crash had already happened.

So describing this result as "Solar misjudged the obstacle" isn't accurate. It returned the right choice for the first obstacle it observed, but the answer didn't arrive in time, which made it hard to use for this real-time game connection. Since it never got past the first obstacle, this also isn't an evaluation of its judgment on the various obstacle types that come later.

Would it be faster called directly instead of through OpenRouter?​

On October 15, 2026, we sent the same request alternately to the Upstage direct API and to Solar Decide on OpenRouter. We used the game's first-obstacle state and the two questions as is, and both sides had 1,031 input tokens. We ran one request at a time on the same computer and measured 10 times per route, excluding 1 warm-up each. Timeout was 15 seconds, with no automatic retries.

The median and range are calculated over successful responses only, and timeouts are shown separately as failures. The direct API's median for successful responses was about 1.54 seconds shorter, but delays of several seconds and a timeout showed up with direct calls too. We can't attribute the whole difference to OpenRouter's relay time. Server load can vary, and the direct API only returned the alias solar-decide, so we couldn't confirm whether its internal model version matches OpenRouter's upstage/solar-decide-20260928.

Download per-route call measurements (CSV)

So is it a network problem rather than the model?​

What we measured is the total time from starting to send the request until the full response body is received. That includes not just network communication but also time spent waiting in a queue on the server, input processing and the time the model takes to compute an answer. Observability tools for inference servers also track queue time and model compute time as separate metrics (NVIDIA Triton docs). That doesn't mean Upstage uses that server.

We didn't get per-stage timings from inside Upstage, so we can't separate whether the problem is the network, server queuing or slow model compute itself. We confirmed the delay reproduced with direct calls, but that alone doesn't mean we measured the model's pure inference speed. Decision accuracy and end-to-end service response time need to be read separately.

Could it have done well at the game if run locally?​

It's possible. If the same model ran on dedicated hardware fast enough that the answer arrived before the jump point, it might clear the first obstacle we observed. Running locally can cut external network round trips and shared-server queuing, but model compute can also be slower on a personal computer, so it isn't automatically faster. An API is just a way of calling a model, so a local model can be served through an API too. What matters is less the name of the call and more where the model runs, on what hardware and under what conditions.

We didn't run Solar Decide locally this time. The official model page lists Upstage Console as the way it's offered, so you'd first need to check separately whether the same model's weights and decision implementation are available for local use. Results from installing some other open model locally can't stand in for Solar's local performance either.

The conclusion we can support here is "Solar's first decision was right, but with this API connection, the answer didn't arrive within the time the game needed." Whether it would have lasted reliably if run locally can only be known by running it again with the same model and control code.

Given time to answer, Solar also got all 18 states right​

In a real-time game, a correct answer that arrives late is useless. So what if we pause the game and wait for the answer? On October 15, 2026, instead of playing the game in real time, we added an evaluation that gives each model the same game state and waits for its answer. In this evaluation, a slow response doesn't cause a crash or count as wrong.

The inputs were the obstacle type, count and height category prepared by the code, the speed, and what the dino was doing at the moment of observation. The correct answer for each state was fixed in advance using the existing action rules: jump for ground obstacles, duck for birds that only block a standing dino, keep running for birds that won't hit even a standing dino. The question also spelled out the selection criteria, so this is closer to a task of picking an action by given rules than to complex reasoning or screen recognition.

We originally planned 24 states, 8 each for jump, duck and keep running. But Claude's call on the 19th state got an HTTP 402 for insufficient credits and we stopped, so we compared only the first 18 states where all seven models responded normally. That shared set has 6 states per action. The 19th state, which only Solar answered, and the 402 response are left out of the table, and we didn't mix in results from a separate run that was stopped earlier by a shared connection failure.

Accuracy, speed and cost on the same 18 states​

We called every model through OpenRouter, ran one request at a time and rotated the model order for each state. Each got the same state, question and options; the decision-only models answered via the Decisions API, and Claude and GPT Mini via the same function-calling format as in the earlier experiment. We applied latency-first routing with provider fallback disabled, and excluded 1 warm-up per model. Max wait was 30 seconds, with no retries. None of the 126 responses used in the comparison had an API error or timeout. P95 is the 95th percentile of the measured response times, which shows how slow the slower responses got.

Cost is the sum of usage.cost from successful responses for these 18 states, in actual dollars. Each model handled the same states and questions 18 times, so totals don't differ because of survival time or call count. Warm-ups, the 19th state, the insufficient-credit response and the separate run stopped by a connection failure are excluded. Top-up fees, taxes and computer costs aren't included either. We sent inputs with the same meaning, but that doesn't mean the API formats and each model's token counting are the same.

To make the small amounts easier to compare, scaling the observed average per call to 1,000 calls gives $0.014089 for MS, $0.028663 for Jev and $0.049278 for OpenAI Decisions. These are proportional projections from these 18 calls, not the result of actually calling 1,000 times. The projections for every model are also in the CSV below.

The accuracy above is the share of answers that matched the predefined action rules, not a game survival rate. For example, Jev's one mismatch was choosing to duck in a situation where it could just keep running. That's an unnecessary move, but it doesn't mean a crash in itself. For the 6 states where jumping was correct, we also checked the jump type separately: Clef chose short vs. full jump differently on 1 of them, so only 13/18 of its responses matched on both action and jump type. Every other model's jump type matched the reference on all 6.

Download the same-state evaluation comparison table (CSV) · Download per-state inputs, answers and responses (CSV)

Solar was accurate, but we couldn't confirm the fast-choice advantage in this API setup​

One of the core advantages of a decision model is returning a choice quickly without generating long text. The official Jev overview and the official Solar overview both emphasize this design. So alongside whether it picked the right answer, you have to check whether that answer arrived in the time you needed.

Given time to answer, Solar got all 18 shared states right. But its median API response time was 5.39 seconds, and in this API setup we couldn't confirm the fast-choice advantage that decision models advertise. Jev responded fast with a median of 0.38 seconds, but its action choices matched the rules on 17/18. OpenAI Decisions and MS Decision-1 got all 18 right in this sample, with medians of 0.45 and 0.65 seconds respectively.

These results can't be stretched into a general ranking of the models' reasoning ability. It's a small task with explicit rules, and each state was called only once. The API time also bundles communication, routing, server queuing and model compute together, so it isn't a measurement that isolates pure inference speed. What it does show is that decision accuracy and end-to-end service response time should be treated as separate metrics.

At work, too, you need to set those two criteria separately. If you're collecting inquiries to classify later, you can wait a few seconds; if you're choosing which urgent alerts to send right away, the correct answer has to arrive within a set time. You can only decide which model to use by checking accuracy on real work data and measuring acceptable response time and cost per call together.

On this task, MS came out ahead on cost and OpenAI on the balance of accuracy and speed​

If we were to start the next evaluation of this task with one model, we'd look at MS Decision-1 first. Its action choices and jump types matched the reference on all 18/18, and its cost for 18 calls, $0.000253596, was the lowest of the seven models. Its median response time was 0.65 seconds. It was about 51% cheaper than Jev but slower to respond, so the choice depends on how much latency you can accept.

Jev was the fastest with a median of 0.38 seconds and was about 42% cheaper than OpenAI. But the median gap with OpenAI was 0.07 seconds, and its action choices matched the reference on 17/18. These results alone weren't enough to recommend Jev ahead of MS or OpenAI. You'd need to check further whether that small speed difference matters in real work and what effect a rule mismatch has.

Solar got 18/18 right but cost more and responded more slowly than MS and OpenAI, so there was little reason to pick it first for this task. Clef was cheaper than Jev, but its action choices were 14/18, and only 13/18 were right on jump type too. Claude and GPT Mini were also more expensive, slower and less consistent with the rules than MS and OpenAI on this task. That doesn't mean the ranking holds for other work like writing documents, coding or complex reasoning.

These selection criteria come from a small experiment that called the same 18 rule-defined states once each. We didn't combine accuracy, speed and cost into an arbitrary score to crown an overall winner. For real work, first decide what one wrong answer costs you and what response time you can accept, then check with more work samples and repeated calls. A model that got 18/18 this time isn't guaranteed to always get it right going forward.

How much did actual gameplay cost?​

The amounts below aren't estimates from plugging input volume into token prices; they're the sum, in dollars, of usage.cost recorded in the successful API responses for each run. Responses requested during a run were included in its cost even if they arrived after the crash. Top-up fees, taxes and computer costs aren't included.

Actual cost of the single best run used in the Reel​

Round 1 Jev ended at 60 seconds of real time, and round 2 Jev and OpenAI Decisions at 300 seconds of real time. Because of things like the wait for the game to start, in-game time was about 59 and 299 seconds respectively.

The two full runs in round 2 had almost the same survival time and 329 calls each. In those two runs Jev cost $0.00942858 and OpenAI Decisions $0.01619360, so Jev was about 42% cheaper. That's a difference observed with this request format and course. Even when you send questions with the same meaning, API formats and token counts differ by model.

Normalizing for survival time: cost per minute of gameplay​

Picking only the single best run can skew the results, so the table below adds up every valid run in each round, including runs that ended early. Round 1 has 7 runs each for Haiku and GPT Mini and 4 for Jev; round 2 has 5 each.

Cost per minute of gameplay = total cost of all valid runs ÷ total in-game survival time × 60

The per-minute figure isn't what it would cost to actually play the same 60 seconds in full. It's the spending rate observed while each model was alive, scaled to one minute. It also doesn't assume a model that crashed would come back and finish a full minute. As the game goes on, speed and obstacle density change, and requests sent right before a crash can finish late, so calls per minute vary.

At the observed spending rate in round 1, Jev was about 18x cheaper than Haiku and about 8.6x cheaper than GPT Mini. In round 2, Clef and MS had lower per-minute costs, but neither completed a 5-minute run. Ending cheaply and lasting long while staying cheap are two different things.

Normalizing by call count instead of time​

Below is the cost from the same logs scaled to 1,000 successful calls. Each call includes both the action question and the jump-type question. Each API has a different input format, so this isn't a comparison of billing for identical token counts.

This tally only includes valid play by the models currently being compared in the two rounds. It excludes warm-ups, requests blocked for insufficient credits, excluded diagnostic runs, the earlier 60-second pilot experiments, the Solar experiment and the follow-up evaluation that gave the same states and waited. The 3 timeouts, where no response came back and the amount couldn't be confirmed, aren't in the totals either, so this isn't total account spend or total development cost. MS's confirmed amount including warm-up was $0.000850122; the table includes only the play cost of $0.000836136. Round 1 mixes default and latency-first routing, and MS was a follow-up experiment, so don't generalize this into a controlled unit-price ranking.

Download the cost comparison data (CSV)

So how do you connect this to your own work?​

In the game, the model received the obstacle state and picked the next move. At work, too, you can start by testing repetitive tasks where you can narrow down the inputs and options.

For example, when an inquiry comes in, the model picks the type and whether to alert, and code routes it to the right AI based on the result. You can set it up so a human only reviews inquiries that are exceptions or meet the review conditions you've defined. Surviving the dino game can't guarantee accuracy on this work. You need to measure classification accuracy, missed urgent inquiries, response latency and cost per call together, using evaluation data made of real inquiries labeled with correct answers.

The takeaway from this experiment for real work is to separate the steps that need a model that writes long explanations from the steps that need an API that quickly picks an option. How this was used in real public projects is collected in the Jev international use case roundup.

Surviving 60 seconds marks when the test ended, not game over​

Every run was set to go for at most 60 seconds of real time. The selected Jev recording shows 59.13 seconds of game time; the two times differ slightly because of the wait for the game to start and when recording began. "Survived to 60 s · test ended" in the Reel means it hadn't crashed by that point, not that the game ended at 60 seconds.

Response time was measured from when the server sent the API request until it got the response. Costs in the tables are the dollar amounts recorded in usage for successful responses. Results change with run time, network and model provider status, and these recordings can't tell us when a crash would have happened in a longer run.

We separated GPT Mini's blocked first call from a real crash​

When we first connected GPT-5.4 Mini, the first request got an HTTP 402. We had requested up to 128 tokens, but the response said the credits remaining at the time could only allow up to 116 tokens. That run had neither a model answer nor a crash, so we didn't count it as a result.

After updating the connection with a usable key, we kept the output limit at 128 tokens and reran the same course. This time we successfully got 13 API responses, and it crashed at 17.19 seconds of game time. We didn't slot the aborted earlier run in as a low survival time, and we didn't lower the output limit for GPT alone.

Keep the AI's choice separate from the code's timing​

This experiment isn't evidence that Jev looked at the screen and played the game like a person. The three models share the code that reads obstacles and handles control timing, and a simple obstacle game like this can be played well by rule-based code alone. In real-time play, what we observed was whether the API's decision arrived in time with this connection setup and course. In the follow-up evaluation, we waited for the answers and checked agreement with the action rules separately. You need both results to tell apart a late answer from a different choice.

In the best-run highlight, the scenes after Claude and GPT Mini crash are shown as freeze frames, and Jev's continued play after they stopped is shown at 8x speed. If you try this yourself, it's better to record the same number of runs per model and compare full results and response-time distributions under the same routing conditions. Adding a baseline run that uses only game rules also makes the effect of adding a model clearer. If you're curious about real work applications, see the inquiry routing, feed filtering and task-path decision cases in the Jev use case roundup.

When you connect a decision model to your work, look at whether the right choice arrives within the time you need, and what that choice costs together. This time Solar got the answers right when we waited, but in the API setup we measured, we couldn't confirm the fast-choice advantage.

This experiment started with connecting Jev, but on this task, MS Decision-1 came out ahead on cost and OpenAI Decisions on the balance of accuracy and speed. Jev having the fastest responses isn't enough on its own to recommend it first. This isn't a model ranking for every kind of work; you should check again with answer data from your real work, and your acceptable response time and cost.

Who this is for​

• You can't yet confidently answer "Why use MCP when you can just use the API?"
• You're building an AI agent and can't decide whether to call the API you already use as is, or wrap it in an MCP server
• You've installed an MCP server but have never seen what happens inside it

You need four things.

curl -LsSf https://astral.sh/uv/install.sh | sh

The uv install command is copied straight from the official uv installation docs. After installing, close and reopen your terminal so the uv command is picked up.

The weather data in this post comes from the public API of Open-Meteo. No sign-up and no API key required, so you can copy, paste and follow along right away.

Step 1. Call the weather API directly with curl​

First, let's pin down exactly what "using an API" means. Paste the line below into your terminal. It asks for the current temperature and wind speed in Seoul (latitude 37.5665, longitude 126.978).

curl "https://api.open-meteo.com/v1/forecast?latitude=37.5665&longitude=126.978&current=temperature_2m,wind_speed_10m&timezone=Asia%2FSeoul"

If you get JSON like this back, it worked. The numbers depend on when you run it.

{"timezone":"Asia/Seoul", ... ,"current":{"time":"2026-10-07T09:00","interval":900,"temperature_2m":14.7,"wind_speed_10m":1.3}}

The point to notice here is that I decided everything.

• Which address (/v1/forecast) to send it to
• What Seoul's latitude and longitude are
• Which values (temperature_2m, wind_speed_10m) to ask for
• When to send the request

An API is a promise: "Send a request in this format, and you get this data." Reading that promise, filling in the values and deciding when to call it are all up to a person (or code a person wrote).

Step 2. Wrap the same function in an MCP server​

Now let's turn the same weather API into a tool an AI can use. Create an empty folder, create a weather_server.py file inside it, and paste in the code below as is.

mkdir weather-mcp && cd weather-mcp

import json
import urllib.parse
import urllib.request

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("korea-weather")

CITIES = {
    "Seoul": (37.5665, 126.9780),
    "Busan": (35.1796, 129.0756),
    "Jeju": (33.4996, 126.5312),
}


@mcp.tool()
def get_current_weather(city: str) -> str:
    """Get the current temperature (°C) and wind speed (km/h) for a city. city must be one of Seoul, Busan or Jeju."""
    if city not in CITIES:
        return f"Unsupported city: {city}. Please use one of Seoul, Busan or Jeju."
    lat, lon = CITIES[city]
    query = urllib.parse.urlencode({
        "latitude": lat,
        "longitude": lon,
        "current": "temperature_2m,wind_speed_10m",
        "timezone": "Asia/Seoul",
    })
    url = f"https://api.open-meteo.com/v1/forecast?{query}"
    with urllib.request.urlopen(url, timeout=10) as res:
        now = json.load(res)["current"]
    return f"{city} as of {now['time']}: temperature {now['temperature_2m']}°C, wind speed {now['wind_speed_10m']}km/h"


if __name__ == "__main__":
    mcp.run()

Look closely and you'll see that the inside is exactly the same API call as Step 1. MCP doesn't remove or replace the API. What changed are two things added on the outside.

1. @mcp.tool(): registers this function as a tool the AI can call.
2. The description sentence in triple quotes right under the function: this becomes the manual the AI reads to decide "when should I use this tool, and with what values?"

Nobody has to memorize latitude and longitude anymore, either. The AI just puts "Busan" in city.

Step 3. Open the "tool description" the AI sees​

An MCP server exchanges messages with the AI app (the client) in a format called JSON-RPC: one message per line, sending and receiving JSON with a fixed shape. Let's do by hand exactly what an AI app does when it first connects to an MCP server.

In the same folder, create an ask.jsonl file and paste in the four lines below.

{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"me","version":"1.0"}}}
{"jsonrpc":"2.0","method":"notifications/initialized"}
{"jsonrpc":"2.0","id":2,"method":"tools/list"}
{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_current_weather","arguments":{"city":"Busan"}}}

Here's what each line means.

Now pipe these messages into the server.

(cat ask.jsonl; sleep 3) | uv run --with "mcp<2" weather_server.py 2>/dev/null

The first run takes a few seconds while uv downloads the MCP Python package. Of the three response lines, the second is the tool description the AI sees. Formatted for readability, it looks like this:

{
  "tools": [{
    "name": "get_current_weather",
    "description": "Get the current temperature (°C) and wind speed (km/h) for a city. city must be one of Seoul, Busan or Jeju.",
    "inputSchema": {
      "properties": {"city": {"title": "City", "type": "string"}},
      "required": ["city"],
      "type": "object"
    }
  }]
}

The function name and description sentence from Step 2 became name and description as is, and city: str became an inputSchema saying "a text value called city is required." The last line contains the actual result.

{"content":[{"type":"text","text":"Busan as of 2026-10-07T09:00: temperature 17.5°C, wind speed 6.2km/h"}],"isError":false}

Now the difference is visible. In Step 1, I knew the address, latitude and longitude, and made the call. In Step 3, the server first describes itself: "I have this tool, and it needs these values." The AI app reads that description, and when a user asks "How's the weather in Busan?", it decides on its own to call get_current_weather with "Busan".

Step 4. Connect it to an AI app and check whether the AI picks the tool​

Now let's plug this server into a real AI app. MCP is a shared standard, so any app that supports MCP can connect to the same server as is. Here I check with Codex CLI, a terminal app you use with a ChatGPT account. If you don't have Codex CLI, install it with the command on the official Codex CLI page, then run codex once and sign in with your ChatGPT account.

① Register the server. Run the command below inside the weather-mcp folder. Replace /absolute/path/ with this folder's actual path, which you can check with pwd.

codex mcp add korea-weather -- uv run --with "mcp<2" /absolute/path/weather-mcp/weather_server.py

If you see Added global MCP server 'korea-weather'., it's registered. Run codex mcp list and korea-weather shows up as enabled.

② Allow this server's tools to run without asking. Codex asks for approval before calling an MCP tool. Since the weather lookup is read-only, open the config file ~/.codex/config.toml and add one line at the bottom of the [mcp_servers.korea-weather] section that was just created.

[mcp_servers.korea-weather]
command = "uv"
args = ["run", "--with", "mcp<2", "/absolute/path/weather-mcp/weather_server.py"]
default_tools_approval_mode = "approve"

default_tools_approval_mode is a setting from the official Codex MCP docs. It's safer not to add this line for tools that edit files or send messages.

③ Just ask a question. Don't mention the tool name, latitude or longitude. Run it with web search turned off (I explain why right below).

codex exec --skip-git-repo-check -c web_search='"disabled"' "Which is warmer right now, Busan or Jeju?"

Here's the result from an actual run on the morning of October 7, 2026.

codex
Current weather changes in real time, so let me check it now. I'll compare the current temperatures in Busan and Jeju on the same basis.
mcp: korea-weather/get_current_weather started
mcp: korea-weather/get_current_weather (completed)
mcp: korea-weather/get_current_weather started
mcp: korea-weather/get_current_weather (completed)
codex
Right now, **Jeju is warmer.**

- Busan: **19.4°C**
- Jeju: **20.5°C**

It called get_current_weather twice: once with Busan and once with Jeju. Nowhere in the question did it say "call get_current_weather twice." The AI read the one line in the description from Step 3 ("city must be one of Seoul, Busan or Jeju") and decided on its own how many times to call the tool and with which values. This is the biggest difference from Step 1, where a person typed in the address, latitude and longitude.

If the AI does the choosing, it might not choose your tool. When I ran the same question with web search turned on, Codex answered by finding the Korea Meteorological Administration's page through web search instead of using korea-weather. When several tools are available, the AI picks one of them. To make sure it uses your tool, turn off the other tools as above, or put the tool name in the question, like "Use the korea-weather tool to tell me ~". With the tool name in the question, it called korea-weather twice and gave the same answer even with web search turned on.

Step 5. Decide whether API or MCP fits your situation​

Based on what we just did, the difference between the two comes down to "who decides what to call, and when."

Use these criteria to choose.

When calling the API directly is the right fit

• Work that must always run in the same order, like payment approval, sign-up, or collecting data at a set time every day
• Work where servers need to exchange data quickly without any AI judgment

When wrapping it in MCP is the right fit

• Internal data or tools you want the AI to pull out on its own when needed during a conversation
• When you want several AI apps to use the same tool without code changes. With 3 AI apps and 4 services to connect, separate integrations mean building 3×4=12 of them, but one MCP server per service means you're done with 4
• When you don't want to give the AI full access. The server in Step 2 exposes only one thing: weather lookups for Seoul, Busan and Jeju. This way, you can narrow what the AI can do in the server code

In short, the right answer is closer to "call the API inside MCP" than "API or MCP?" If you already have an API you use, there's no need to throw it away: just wrap it with a description as in Step 2, and it becomes a tool the AI can use.

If you hit an error, check here first​

Wrap-up​

Call the API directly with curl → wrap the same call as an MCP tool in one Python file → check the description the AI sees with tools/list → connect it to an AI app → pick the approach that fits your situation. With these five steps, you can see the difference between API and MCP for yourself instead of memorizing definitions. Next, pick a public data API you already use instead of Open-Meteo and swap out only the inside of the function from Step 2. You can also compare for yourself how well the AI picks the tool depending on how you write the description sentence.

References​

• Official Model Context Protocol docs: MCP architecture and specification
• Anthropic's official intro video: Introducing the Model Context Protocol
• Open-Meteo: the free weather API used in this post
• MCP Python SDK 2.x migration guide

What it looks like when it's done​

On the morning of October 6, 2026, I re-tested it by commenting GPX from a different account on a Reel on @course.hanjang, an account I run. A few seconds after commenting, a public reply appeared. (The account posts in Korean, so the messages in these screenshots are in Korean.)

The follow prompt was waiting in my DMs. When I replied "Done", the workflow checked that I followed the account and then sent the link for that trail course. Because I was on desktop web, the [Followed] button wasn't shown, so I typed "Done" as the message instructed.

The 3-minute summary: do it in this order​

If you're short on time, you can follow just this list. The real screens and the spots where people get stuck are in Steps 1-9 below.

1. Create a Meta app. Create an app at developers.facebook.com and pick the use case Manage messaging and content on Instagram. Add the three permissions (basic, manage_comments, manage_messages).
2. Make your account a tester. In App roles, add your Instagram account as an Instagram Tester, then accept it in Instagram under Settings → Apps and websites → Tester invites.
3. Generate a token. On the API setup screen, click Generate token and save the token and the Instagram app secret in your password manager.
4. Prepare n8n. Create two credentials (Header Auth for the token, Crypto for the secret) and two tables (dm_rules, dm_log). Every column is a string.
5. Paste in the workflow. Grab the workflow file for free from the link in Step 5, paste it in, re-select just the verify_token, credentials and tables, then Publish.
6. Connect the webhook. In Meta Webhooks, enter your n8n URL and verify_token and subscribe only to comments and messages. Run the subscribed_apps call once.
7. Publish the app. Add a privacy policy URL and switch the app to Published (Live). In development mode, real comment notifications don't arrive.
8. Register a Reel and test. Add one row to dm_rules with the Reel's media_id, keyword and link, then confirm by leaving a keyword comment from an account that isn't yours.

Who this is for​

• Creators and small business owners who want to run "comment and I'll send you the resource" campaigns on Reels and posts
• People who'd rather build it themselves and understand how it works than pay for a DM automation tool like ManyChat
• n8n users who want a real-world example of receiving events from an external service via webhook

You'll need four things:

1. A professional Instagram account (Business or Creator) that is public. Private accounts don't get comment notifications.
2. A Meta developer account (developers.facebook.com)
3. An n8n instance reachable from the internet over HTTPS. n8n Cloud or self-hosted with a domain both work. I used self-hosted n8n 2.38.5.
4. A privacy policy URL to enter when you publish the app

All screens and settings here are ones I built and verified myself on October 3, 2026. I called the Graph API at v24.0, and the Meta webhook dashboard showed v26.0.

First, how a comment becomes a DM​

The official name for this feature is Private Replies. It's an Instagram API feature that lets you send one DM to someone who commented on your post, based on that comment. You can send it even if they don't follow you; in that case it lands in their message requests.

The official Meta docs boil down to three rules:

• You can send only one DM per comment.
• You must send it within 7 days of the comment.
• If the person replies, you can send further messages for the next 24 hours.

Here's the overall flow. When someone comments, Meta sends a "new comment" notification to your server (n8n, here). This notification is called a webhook. n8n checks that the notification really came from Meta, looks for the keyword, makes sure that comment hasn't been handled already, and then sends the DM.

There's one important constraint. You can only check via the API whether someone follows you after they've sent you a DM. According to the User Profile API docs, if you try to fetch a profile before the app user has messaged the app, you get an error saying user consent is required. And the is_user_follow_business field, which tells you whether they follow you, lives in exactly that API.

So the order works like this: in reply to the comment, send a prompt that says "Follow, then tap the button" along with a button. Only when they tap the button or reply do you check whether they follow and send the link. Tapping the button counts as sending you a DM, so the condition for the lookup is met.

Here's the finished n8n workflow. The top three nodes handle the one-time check where Meta asks "Is this URL really your server?", the middle row receives comments and sends the follow prompt, and the bottom row checks follow status from the person's DM reply.

Step 1. Create a Meta app and add three Instagram API permissions​

In Meta for Developers, click Create app.

1. Name the app. Matching it to your account name saves confusion later.
2. In the use case list, change the filter to All and pick Manage messaging and content on Instagram.
3. Connect a business portfolio. If you'll want App Review (Advanced Access) later, you need a business-verified portfolio, so pick that if you have one.
4. When you click Create app, it asks for your password again.

Once the app exists, go to Use cases → Customize → API setup with Instagram login. Click Add all required permissions in box 1 and these three permissions are added. They're the only ones this feature needs.

The top of the same screen shows the Instagram app ID and the Instagram app secret. You'll use the secret in Step 4 to verify webhook signatures. These are different from the Facebook app ID, so don't mix them up.

Step 2. Add your Instagram account as an Instagram Tester and accept​

For the app to access your account, that account needs a role in the app.

1. In the app's left menu, go to App roles → Roles and click Add people.
2. Choose Instagram Tester at the very bottom of the role list, enter your Instagram username and add it. The status shows "Pending".

3. Log in to Instagram on the web with that account, then go to Settings → Website permissions → Apps and websites → Tester invites and click Accept. The direct URL is instagram.com/accounts/manage_access/.

The invite doesn't show up under "Connected experiences" in Meta Accounts Center. Look for it in the Tester invites tab in Instagram's own settings.

Step 3. Generate an access token​

In box 2 on the API setup screen, Generate access tokens, click Generate token next to your account and an Instagram login window opens.

On the permissions consent screen, you can turn off Access and publish content and Access and manage insights. This feature only uses comments and messages, so it's safer not to grant permissions you don't need in the first place.

Once you allow it, the token is shown exactly once. You have to tick I understand before the token appears and can be copied. Save it to your password manager right away. Also note down the number shown in the same window (your Instagram user ID).

You can check the token straight from your browser's address bar:

https://graph.instagram.com/v24.0/me?fields=user_id,username&access_token=YOUR_ACCESS_TOKEN

If your username comes back, it works. This token expires, so if you keep running this you'll need to refresh it before it does.

Step 4. Create two credentials and two Data tables in n8n​

So you never paste secrets directly into the workflow, set up storage first.

Credential 1: token (Header Auth)

• Credentials → Create credential → Header Auth
• Name: Authorization, Value: Bearer YOUR_ACCESS_TOKEN (one space after Bearer)
• Change Allowed HTTP Request Domains to Specific Domains and enter only graph.instagram.com. This keeps the token from leaking to any other host.

Credential 2: app secret (Crypto)

• Create credential → Crypto → put the Instagram app secret from Step 1 in Hmac Secret.
• It's used to compute the signature that proves a webhook really came from Meta.

Data table 1: dm_rules (which post, which keyword, what to send)

Create four columns, all string type: media_id, keyword, title, link.

Do not make media_id a number. Instagram media IDs are 17 digits long, like 17949931728293330, and storing them as numbers changes the last digits. Importing a CSV may also guess "number", so it's safer to create an empty table and enter rows by hand.

You can look up a post's media_id with your token:

https://graph.instagram.com/v24.0/me/media?fields=id,permalink,caption&access_token=YOUR_ACCESS_TOKEN

Use permalink to identify the Reel, then put its id in media_id. An example row:

The table I actually run has one row per Reel, as below. This screen is from my own account, so the title column is named course_name, but the downloadable workflow JSON uses title. If you're creating the table from scratch, name it title.

Data table 2: dm_log (send history, for duplicate prevention)

Seven columns, all string: comment_id, media_id, username, comment_text, status, error, igsid.

Don't skip igsid. When someone who got the follow prompt later replies "Done", the workflow uses this value to find their pending request. Without the column, the comment-side DM goes out but the link DM never does.

Step 5. Bring in the workflow and change just three things​

You don't need to build all 29 nodes from scratch. I've put the finished workflow file on Groble (a Korean digital-product marketplace) as a free (0 KRW) product. Unzip the download, open the JSON file, copy everything, click an empty n8n canvas and paste. The ZIP also includes a README listing the changes below.

Get the Instagram comment auto-DM workflow for free (Groble)

The node names in the downloadable workflow are in Korean. Below I've translated them and put the original label in parentheses where it helps you find the node.

After pasting, change three things:

1. In the verify_token matches? node (verify_token 일치?), replace the comparison value 여기에_내가_정한_verify_token (a placeholder meaning "your verify_token goes here") with a long string nobody could guess. You'll enter the exact same value in Meta in Step 7.
2. In the seven nodes that use credentials (Compute signature, the two Follow-prompt DM nodes, Reply to comment, Check follow status, Send link DM, Follow reminder), select the credentials from Step 4.
3. In the eight Data table nodes, re-select dm_rules and dm_log. You have to pick the table from the list once more for the columns to load.

@{계정핸들} in the JSON is the placeholder for your account handle in the follow-prompt message. Put your Instagram account there, and change the default link in the Build link message code node (링크 메시지 만들기) to your own site's listing page.

Here's what each node does. If this is new to you, open the nodes one by one in this order and the structure will click.

The core DM call is a single request. The first DM, replying to a comment, specifies the recipient by comment ID rather than user ID; follow-up DMs are sent by IGSID.

POST https://graph.instagram.com/v24.0/{your Instagram user ID}/messages
Authorization: Bearer {token}

{"recipient": {"comment_id": "{comment ID}"}, "message": {"text": "Follow us, then tap the button.", "quick_replies": [{"content_type": "text", "title": "Followed", "payload": "FOLLOW_CHECK"}]}}

When the button is tapped, the DM arrives with payload set to FOLLOW_CHECK. Quick replies aren't displayed on desktop, so the prompt also says "If you don't see the button, reply 'Done'", and the DM branch accepts replies that arrive as plain text too.

Step 6. Publish the workflow and test the URL first​

Click Publish in the top right. Publishing is what activates the production webhook URL (https://your-n8n-host/webhook/ig-comment-dm).

Before registering it with Meta, check it yourself in the browser:

https://your-n8n-host/webhook/ig-comment-dm?hub.mode=subscribe&hub.challenge=12345&hub.verify_token=YOUR_VERIFY_TOKEN

If the page shows only 12345, it's working. If you deliberately enter the wrong token, you should get forbidden. Once both check out, move on to the Meta side.