Forem: bluefin ships

Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)

bluefin ships — Wed, 29 Apr 2026 07:26:04 +0000

I spent six weeks in early 2026 trying to build a "personal AI ops" stack — the kind of small daemons that handle email triage, market summaries, meeting notes, the boring infra of a knowledge worker's day.

I tried LangChain. Then LangGraph. Then CrewAI. Then a Zapier subscription. I shipped nothing for a month.

Then I deleted all of it and wrote ten Python files. Each one does one job, in 15-30 lines of core logic. They've been running on my Mac via launchd for the last three weeks. This is what I learned.

The architecture (it's almost embarrassingly small)

launchd / cron
       │
       ▼
 Recipe (.py)        ← single file, no framework
       │
   ┌───┼───┐
   ▼   ▼   ▼
 API   Web  Local
 fetch scrape files
       │
       ▼
 AI layer (3-tier fallback)
   ① Claude API
   ② Ollama local
   ③ raw passthrough
       │
       ▼
 Push (Discord / Telegram / stdout)

Every agent follows the same pipeline: fetch → reason → push. That's it. Once you internalize that shape, you stop reaching for frameworks.

Recipe 1: Gmail triage in 18 lines

from googleapiclient.discovery import build
import anthropic, json

def triage_today(creds):
    gmail = build('gmail', 'v1', credentials=creds)
    msgs = gmail.users().messages().list(
        userId='me', q='newer_than:1d', maxResults=30).execute()

    summaries = []
    for m in msgs.get('messages', []):
        full = gmail.users().messages().get(userId='me', id=m['id']).execute()
        snippet = full.get('snippet', '')[:300]
        subject = next((h['value'] for h in full['payload']['headers']
                        if h['name']=='Subject'), '')
        summaries.append(f"{subject} | {snippet}")

    judged = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=600,
        messages=[{"role":"user","content":
          f"Rank these emails 1-10 by importance to a freelance dev. "
          f"Return JSON [{{i, score, why}}]. Top 5 only.\n\n"
          + "\n".join(f"[{i}] {s}" for i,s in enumerate(summaries))}])
    return json.loads(judged.content[0].text)

No agent framework. No tool-use loop. Just: fetch the data, give Claude the data, parse the answer. Run it at 21:00 via launchd, push the top-5 to LINE Notify. Done.

Recipe 3: Hacker News morning digest

import requests, anthropic

def hn_digest():
    ids = requests.get("https://hacker-news.firebaseio.com/v0/topstories.json").json()[:10]
    stories = [requests.get(
        f"https://hacker-news.firebaseio.com/v0/item/{i}.json").json() for i in ids]

    prompt = "Summarize each in 2 lines (Traditional Chinese), keep title English:\n\n"
    prompt += "\n".join(f"{s['title']} — {s.get('url','(text)')}" for s in stories)

    out = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=1500,
        messages=[{"role":"user","content":prompt}])
    return out.content[0].text

Eleven lines. Runs at 06:00. Pushes to my Discord. Replaces three RSS readers and a habit of doom-scrolling HN at breakfast.

Recipe 10: Multi-AI judge

The one I lean on most. When I'm stuck on a real decision, I fan out to Claude + GPT-4o + Gemini in parallel, then have Claude judge the panel:

import asyncio

async def judge(question):
    answers = await asyncio.gather(
        ask_claude(question), ask_gpt4o(question), ask_gemini(question),
        return_exceptions=True)

    verdict = anthropic.Anthropic().messages.create(
        model="claude-opus-4", max_tokens=1500,
        messages=[{"role":"user","content": f"""
Question: {question}

[Claude]: {answers[0]}
[GPT-4o]: {answers[1]}
[Gemini]: {answers[2]}

1. Where do they agree?
2. Where do they disagree, who's more defensible?
3. Final call + confidence 1-10."""}])
    return verdict.content[0].text

Cost: ~$0.05 per call. Worth it on anything I'd otherwise spend 20 minutes turning over.

Why I stopped using frameworks

LangChain optimizes for "any LLM, any tool, any chain" — which means three layers of abstraction sitting between you and the API call you actually wanted to make. Every time it broke (and it broke often), debugging meant tracing through code I didn't write.

Pure Python + the official SDKs gave me:

Files I can grep
Stack traces that make sense
The ability to swap Claude for Ollama in one line
Cron-friendly behavior (no daemon, no warm-up, just run and exit)

If your agent fits in 30 lines, a framework is a tax, not a tool.

The fallback pattern that saved me

Every recipe has this:

def reason(prompt):
    try:
        return claude_call(prompt)
    except Exception:
        try:
            return ollama_call(prompt)  # local llama3
        except Exception:
            return prompt  # raw passthrough — at least the data still flows

I lost two days last month to an Anthropic outage. Now my morning digest still arrives — degraded, sometimes just raw HN titles, but it arrives. Resilience is a feature.

Try it yourself

I packaged all 10 recipes as Agent Cookbook — single-file scripts, launchd/cron templates, full setup guide. $19 one-time, no subscription, the code is yours to fork.

https://vampireheart3.gumroad.com/l/agent-cookbook

Or just steal the patterns above. The architecture diagram is the actual product — the code is just a faithful copy of it.

Why Your Python Voice Assistant Should Use Whisper + Claude (Not SpeechRecognition)

bluefin ships — Mon, 27 Apr 2026 11:47:38 +0000

If you Google "ai voice assistant python" today, the top results still teach SpeechRecognition + pyttsx3 + Google's free STT endpoint. That stack is from 2020. It's slow, cloud-locked, and the recognition quality on accented English is rough.

This is Part 3 of the BFO_ships AI agents series.

Part 1: Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)
Part 2: Building a phone-call-style AI voice assistant in pure Python
Part 3 (this post): why the Whisper + Claude stack beats the legacy one, with benchmarks and runnable code

If you've never touched a voice assistant project, the TL;DR is this: in 2026, you don't need Google's STT API and you don't need a robotic pyttsx3 voice. You can run Whisper locally and let Claude handle the brain. It's faster, cheaper at scale, and the output sounds human.

The legacy stack (what most tutorials still teach)

import speech_recognition as sr
import pyttsx3

r = sr.Recognizer()
engine = pyttsx3.init()

with sr.Microphone() as source:
    audio = r.listen(source)
    text = r.recognize_google(audio)  # cloud call, English-biased
    engine.say(f"You said {text}")
    engine.runAndWait()

Three problems with this:

recognize_google hits an undocumented Google endpoint. Rate-limited, can disappear any day.
pyttsx3 uses your OS's built-in TTS. On macOS it's okay, on Windows/Linux it sounds like a 2005 GPS.
The "intelligence" layer is missing. You can transcribe, you can speak, but there's no reasoning.

The 2026 stack: Whisper + Claude + a real TTS

mic -> whisper.cpp (local STT) -> Claude API (brain) -> say / ElevenLabs (TTS) -> speaker

Why each piece:

whisper.cpp: C++ port of OpenAI Whisper. Runs on CPU. The base.en model is 142MB and transcribes 10 seconds of audio in under a second on an M1.
Claude API: actually understands what the user means and can call tools. Not just keyword matching.
macOS say or ElevenLabs: say is free and sounds fine. ElevenLabs is paid but indistinguishable from a human.

Install

# Whisper (C++ build, no Python deps for the heavy lifting)
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && make
bash ./models/download-ggml-model.sh base.en

# Python client side
pip install anthropic sounddevice scipy

Minimal end-to-end script

import os
import subprocess
import sounddevice as sd
from scipy.io.wavfile import write
from anthropic import Anthropic

WHISPER_BIN = "./whisper.cpp/main"
WHISPER_MODEL = "./whisper.cpp/models/ggml-base.en.bin"
client = Anthropic()  # reads ANTHROPIC_API_KEY


def record(seconds=5, path="in.wav", rate=16000):
    print("listening...")
    audio = sd.rec(int(seconds * rate), samplerate=rate, channels=1, dtype="int16")
    sd.wait()
    write(path, rate, audio)
    return path


def transcribe(wav_path):
    out = subprocess.run(
        [WHISPER_BIN, "-m", WHISPER_MODEL, "-f", wav_path, "-nt", "-otxt"],
        capture_output=True, text=True,
    )
    txt_path = wav_path + ".txt"
    if os.path.exists(txt_path):
        return open(txt_path).read().strip()
    return out.stdout.strip()


def think(user_text):
    msg = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=300,
        system="You are a concise voice assistant. Reply in 1-2 sentences.",
        messages=[{"role": "user", "content": user_text}],
    )
    return msg.content[0].text


def speak(text):
    subprocess.run(["say", "-v", "Samantha", text])


if __name__ == "__main__":
    while True:
        wav = record(seconds=5)
        heard = transcribe(wav)
        if not heard:
            continue
        print(f"you: {heard}")
        reply = think(heard)
        print(f"bot: {reply}")
        speak(reply)

That's the whole loop. Roughly 50 lines. No Google account, no rate limit, no internet for the STT step.

Benchmarks I actually ran

On an M1 MacBook Air, 5 seconds of recorded audio:

Step	Legacy stack	Whisper + Claude
STT latency	1.2 s (network)	0.4 s (local)
STT accuracy on accented English	~70%	~95%
Reasoning quality	none	Claude Haiku
Cost per 1000 turns	free but rate-limited	~$0.30 (Claude Haiku) to ~$3 (Opus)
Works offline	no	STT yes, brain no

The "works offline for STT" part matters more than people think. If you're prototyping on a train, in a co-working space with flaky wifi, or shipping to a kiosk device, local STT is the difference between "works" and "doesn't."

Why "Why Whisper + Claude" beats "How to use SpeechRecognition" in 2026

Three reasons, plain:

Whisper is open source and ships forward. OpenAI keeps releasing better Whisper models. SpeechRecognition is a wrapper around endpoints that may vanish.
Claude actually reasons. A voice assistant that only transcribes is a dictation tool. A voice assistant that can answer "what's on my calendar tomorrow and should I move the 3pm?" is an assistant. That requires a real LLM.
You own the stack. Local STT plus a single API key beats four cloud dependencies. Fewer points of failure, fewer Terms of Service to read.

What to build next

The script above is a loop. To make it useful you want:

Wake word so it doesn't record every 5 seconds. Use pvporcupine (free tier).
Tool use so Claude can read your calendar, send messages, search files. Claude's tool use API is built for this.
Streaming TTS so the reply starts speaking before Claude finishes generating. ElevenLabs has a streaming endpoint.

Each of those is a weekend. Together they're a real product.

If you want the full agent playbook

I packaged the 10 agents from Part 1, the voice assistant from Part 2, and the patterns above into a cookbook with copy-paste recipes, system prompts, and the orchestration code that ties them together.

Agent Cookbook on Gumroad — $19

It's the version of this post with no shortcuts cut: full code, full prompts, full orchestrator.

Next in the series: Part 4 will cover giving the assistant tool use so it can actually do things, not just talk.

Building a phone-call-style AI voice assistant in pure Python

bluefin ships — Mon, 27 Apr 2026 09:21:27 +0000

I wanted an AI I could talk to like a phone call — press a button, speak Mandarin, hear it answer back in 2 seconds. No ChatGPT Voice paywall. No LangChain. No "hosted agent" SaaS that locks my conversation history behind someone else's dashboard.

So I built it in 150 lines of Python. Round-trip latency: 2.4 seconds. Monthly cost: ~$0.

This is part 2 of my pure Python AI series. Part 1 was 10 agents in stdlib. This one is the voice stack.

The pain

Every "AI voice app" on the market is broken in at least one of these ways:

ChatGPT Voice — gated behind Plus, no API for the realtime voice mode that actually feels like a phone call, and English-first.
ElevenLabs / PlayHT — billed per character, the free tier evaporates in a week, and you're locked into their TTS.
Vapi / Retell / Bland — hosted agent platforms, $0.05–$0.15 per minute, your transcripts live on their servers.
Most open-source voice repos — wired together with LangChain, 14 abstractions deep, breaks the moment a provider deprecates an endpoint.

I'm in Taiwan. I want Traditional Chinese in, Traditional Chinese out, low latency, no monthly bill, and code I can actually read on a Sunday afternoon.

So: stdlib + three subprocesses + one HTTP endpoint.

The architecture

iPhone (Shortcut: record audio + POST)
        │  multipart/form-data: audio.wav + convo_id
        ▼
┌────────────────────────────────────────────┐
│  Mac server :8765 (http.server, stdlib)    │
│                                            │
│   1. Whisper STT  (whisper.cpp / ggml-base)│
│            │ text                          │
│            ▼                               │
│   2. LLM router  (NIM → Gemini → Claude)   │
│            │ reply text                    │
│            ▼                               │
│   3. Edge TTS    (zh-TW-HsiaoChenNeural)   │
│            │ wav bytes                     │
└────────────┼───────────────────────────────┘
             ▼
    audio/wav response → iPhone plays

Three local processes, one HTTP handler, one in-memory dict for conversation state. That's the whole thing.

The pipeline (3 snippets that matter)

1. STT via whisper.cpp subprocess

No openai-whisper Python wheel, no PyTorch, no 4 GB of CUDA junk. Just the C++ binary.

import subprocess, tempfile, os

def transcribe(wav_bytes: bytes) -> str:
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        f.write(wav_bytes)
        path = f.name
    try:
        subprocess.run(
            [
                "whisper-cli",
                "-m", "models/ggml-base.bin",
                "-l", "zh",
                "-f", path,
                "-otxt", "-of", path,
                "--no-prints",
            ],
            capture_output=True, text=True, timeout=30,
        )
        with open(path + ".txt") as t:
            return t.read().strip()
    finally:
        for p in (path, path + ".txt"):
            if os.path.exists(p): os.unlink(p)

ggml-base.bin is 142 MB. On an M-series Mac it transcribes a 5-second clip in ~600ms. Good enough.

2. LLM router with three-tier fallback

A single provider going down should not kill the call. Try the free fast one first, fall back to the free smart one, last resort the paid one.

import os, json, urllib.request

PROVIDERS = [
    ("nim",     "https://integrate.api.nvidia.com/v1/chat/completions",
                "meta/llama-4-maverick-17b-128e-instruct",
                os.environ["NIM_API_KEY"]),
    ("gemini",  "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
                "gemini-2.5-pro",
                os.environ["GEMINI_API_KEY"]),
    ("claude",  "https://api.anthropic.com/v1/messages",
                "claude-haiku-4-5",
                os.environ["ANTHROPIC_API_KEY"]),
]

def llm(messages: list[dict]) -> str:
    for name, url, model, key in PROVIDERS:
        try:
            if name == "claude":
                return _call_anthropic(url, key, model, messages)
            body = json.dumps({"model": model, "messages": messages,
                               "temperature": 0.6, "max_tokens": 400}).encode()
            req = urllib.request.Request(url, data=body, headers={
                "Authorization": f"Bearer {key}",
                "Content-Type": "application/json",
            })
            with urllib.request.urlopen(req, timeout=8) as r:
                data = json.loads(r.read())
                return data["choices"][0]["message"]["content"].strip()
        except Exception as e:
            print(f"[llm] {name} failed: {e}")
            continue
    return "（系統忙線中、請稍後再說一次）"

NVIDIA NIM gives free inference on Llama 4 Maverick at decent rate limits. Gemini Pro free tier covers the rest. Claude is the "I'm willing to pay 3 cents to not embarrass myself" tier.

3. Conversation memory + the HTTP handler

The whole point of "phone-call-style" is multi-turn. Each iPhone request carries a convo_id; we keep history in a dict.

import edge_tts, asyncio
from http.server import BaseHTTPRequestHandler, HTTPServer
import cgi, io

HISTORY: dict[str, list[dict]] = {}
SYSTEM = {"role": "system",
          "content": "你是一個說繁體中文的語音助理、回答簡短、口語、自然、不超過 80 字。"}

async def synth(text: str) -> bytes:
    buf = io.BytesIO()
    comm = edge_tts.Communicate(text, voice="zh-TW-HsiaoChenNeural")
    async for chunk in comm.stream():
        if chunk["type"] == "audio":
            buf.write(chunk["data"])
    return buf.getvalue()

class Voice(BaseHTTPRequestHandler):
    def do_POST(self):
        form = cgi.FieldStorage(fp=self.rfile, headers=self.headers,
                                environ={"REQUEST_METHOD": "POST"})
        convo_id = form.getvalue("convo_id", "default")
        wav = form["audio"].file.read()

        user_text = transcribe(wav)
        hist = HISTORY.setdefault(convo_id, [SYSTEM])
        hist.append({"role": "user", "content": user_text})

        reply = llm(hist)
        hist.append({"role": "assistant", "content": reply})
        HISTORY[convo_id] = hist[-21:]  # cap at 10 turns + system

        audio = asyncio.run(synth(reply))
        self.send_response(200)
        self.send_header("Content-Type", "audio/mpeg")
        self.end_headers()
        self.wfile.write(audio)

HTTPServer(("0.0.0.0", 8765), Voice).serve_forever()

iPhone Shortcut: record → POST https://your-tunnel/voice with audio and convo_id → play the response. Done. No app, no TestFlight.

The cost reality

Measured over a week of personal use, ~30 conversations/day, 4–6 turns each:

Component	Provider	Cost
STT	whisper.cpp local	$0
LLM (95% of calls)	NVIDIA NIM Llama 4 Maverick	$0 (free tier)
LLM (4% fallback)	Gemini 2.5 Pro	$0 (free tier)
LLM (1% fallback)	Claude Haiku 4.5	~$0.04/week
TTS	Microsoft Edge `edge-tts`	$0
Hosting	Mac mini at home + Cloudflare Tunnel	$0
Total		~$0.16/month

Compare to Vapi at $0.10/minute — same usage would be ~$45/month. The home-server tax is electricity.

Why no LangChain

I wrote the whole thing in one sitting because every component is the dumbest possible version of itself: a subprocess, an HTTP POST, a dict, an async TTS stream. When NIM changes their model name next month, I edit one tuple. When Edge TTS gets blocked, I drop in Piper without rewriting a "Chain".

Boring is good. Boring code survives provider deprecations. The day a framework abstracts your requests.post into a RunnableLambda, you've signed up to debug someone else's metaphor at 2 AM.

Try it yourself

Full source plus the iPhone Shortcut JSON, the Cloudflare Tunnel config, the Asterisk AGI bridge (so the same backend can answer real SIP phone calls), and 9 more pure-Python AI recipes — packaged as Agent Cookbook for $19, one-time, lifetime updates.

https://vampireheart3.gumroad.com/l/agent-cookbook

If you build something with it, leave a comment — I want to hear what your voice agent sounds like.

— BFO

Part 1: Building 10 AI agents in pure Python (no LangChain)
Part 2 (this one): Phone-call-style voice assistant
Part 3 (next): Giving the assistant tools — real function-calling without an SDK

Building 10 AI agents in pure Python (no LangChain, no SaaS, no BS)

bluefin ships — Sun, 26 Apr 2026 14:43:19 +0000

I tried LangChain. Then LangGraph. Then CrewAI. Then a Zapier subscription. I shipped nothing for a month.

The architecture (it's almost embarrassingly small)

launchd / cron
       │
       ▼
 Recipe (.py)        ← single file, no framework
       │
   ┌───┼───┐
   ▼   ▼   ▼
 API   Web  Local
 fetch scrape files
       │
       ▼
 AI layer (3-tier fallback)
   ① Claude API
   ② Ollama local
   ③ raw passthrough
       │
       ▼
 Push (Discord / Telegram / stdout)

Every agent follows the same pipeline: fetch → reason → push. That's it. Once you internalize that shape, you stop reaching for frameworks.

Recipe 1: Gmail triage in 18 lines

from googleapiclient.discovery import build
import anthropic, json

def triage_today(creds):
    gmail = build('gmail', 'v1', credentials=creds)
    msgs = gmail.users().messages().list(
        userId='me', q='newer_than:1d', maxResults=30).execute()

    summaries = []
    for m in msgs.get('messages', []):
        full = gmail.users().messages().get(userId='me', id=m['id']).execute()
        snippet = full.get('snippet', '')[:300]
        subject = next((h['value'] for h in full['payload']['headers']
                        if h['name']=='Subject'), '')
        summaries.append(f"{subject} | {snippet}")

    judged = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=600,
        messages=[{"role":"user","content":
          f"Rank these emails 1-10 by importance to a freelance dev. "
          f"Return JSON [{{i, score, why}}]. Top 5 only.\n\n"
          + "\n".join(f"[{i}] {s}" for i,s in enumerate(summaries))}])
    return json.loads(judged.content[0].text)

No agent framework. No tool-use loop. Just: fetch the data, give Claude the data, parse the answer. Run it at 21:00 via launchd, push the top-5 to LINE Notify. Done.

Recipe 3: Hacker News morning digest

import requests, anthropic

def hn_digest():
    ids = requests.get("https://hacker-news.firebaseio.com/v0/topstories.json").json()[:10]
    stories = [requests.get(
        f"https://hacker-news.firebaseio.com/v0/item/{i}.json").json() for i in ids]

    prompt = "Summarize each in 2 lines (Traditional Chinese), keep title English:\n\n"
    prompt += "\n".join(f"{s['title']} — {s.get('url','(text)')}" for s in stories)

    out = anthropic.Anthropic().messages.create(
        model="claude-sonnet-4", max_tokens=1500,
        messages=[{"role":"user","content":prompt}])
    return out.content[0].text

Eleven lines. Runs at 06:00. Pushes to my Discord. Replaces three RSS readers and a habit of doom-scrolling HN at breakfast.

Recipe 10: Multi-AI judge

The one I lean on most. When I'm stuck on a real decision, I fan out to Claude + GPT-4o + Gemini in parallel, then have Claude judge the panel:

import asyncio

async def judge(question):
    answers = await asyncio.gather(
        ask_claude(question), ask_gpt4o(question), ask_gemini(question),
        return_exceptions=True)

    verdict = anthropic.Anthropic().messages.create(
        model="claude-opus-4", max_tokens=1500,
        messages=[{"role":"user","content": f"""
Question: {question}

[Claude]: {answers[0]}
[GPT-4o]: {answers[1]}
[Gemini]: {answers[2]}

1. Where do they agree?
2. Where do they disagree, who's more defensible?
3. Final call + confidence 1-10."""}])
    return verdict.content[0].text

Cost: ~$0.05 per call. Worth it on anything I'd otherwise spend 20 minutes turning over.

Why I stopped using frameworks

Pure Python + the official SDKs gave me:

Files I can grep
Stack traces that make sense
The ability to swap Claude for Ollama in one line
Cron-friendly behavior (no daemon, no warm-up, just run and exit)

If your agent fits in 30 lines, a framework is a tax, not a tool.

The fallback pattern that saved me

Every recipe has this:

def reason(prompt):
    try:
        return claude_call(prompt)
    except Exception:
        try:
            return ollama_call(prompt)  # local llama3
        except Exception:
            return prompt  # raw passthrough — at least the data still flows

I lost two days last month to an Anthropic outage. Now my morning digest still arrives — degraded, sometimes just raw HN titles, but it arrives. Resilience is a feature.

Try it yourself

I packaged all 10 recipes as Agent Cookbook — single-file scripts, launchd/cron templates, full setup guide. $19 one-time, no subscription, the code is yours to fork.

https://vampireheart3.gumroad.com/l/agent-cookbook

Or just steal the patterns above. The architecture diagram is the actual product — the code is just a faithful copy of it.

Taiwan-localized AI tools comparison: 15 tools tested for TW developers

bluefin ships — Sat, 25 Apr 2026 09:15:37 +0000

If you're building or working from Taiwan, you've probably hit the same wall I did:
most "best AI tools" lists are written for US developers and don't tell you whether the tool will accept your TW credit card or issue a Taiwan invoice (三聯式發票).

So I tested 15 popular AI tools from a Taiwan user's perspective. Here's the gist:

The 3 must-haves (free tier is enough for most)

ChatGPT free — solid baseline
Claude (anthropic.com) — strongest Chinese output, accepts TW cards
Perplexity — best for research with citations

4 worth upgrading (under $25/mo)

Claude Pro / Perplexity Pro / ChatGPT Plus — all ~$20
Grammarly — only useful if you write a lot of English

3 you probably shouldn't buy

Notion AI — only worth it if you're already a Notion power user
Jasper ($49/mo) — Chinese output is "Google Translate-flavored"
Copy.ai — pricing doesn't justify outputs vs Claude

Taiwan-specific notes (the part nobody else writes)

All 15 tools accept TW credit cards (with foreign-currency support)
None of them issue Taiwan三聯式發票 — companies that need invoices can't expense any of these
Some tools occasionally bundle with telecom carriers (e.g. Perplexity x 中華電信) — keep an eye out

Full comparison (in Chinese) with affiliate disclosure: https://abang.bluefin.work/posts/tw-ai-tools-2026-list

I'll re-test every 30 days. Curious what other regional gotchas you've hit elsewhere (EU VAT? Brazil? India?).

ai #taiwan #devtools

I Rode a Scooter in the Rain for 12 Hours. My 6 AI Agents Shipped a Product.

bluefin ships — Fri, 24 Apr 2026 10:07:04 +0000

Today I rode my 125cc scooter through Taipei rain for twelve hours and made NT$2,100 (about US$65) delivering lunch and dinner shifts.

In the exact same window, my phone was running six AI agents. By the time I peeled off the wet jacket, a $19 product was live on Gumroad. I didn't touch a keyboard.

This is not a manifesto. This is a Thursday.

The team that ships while I ride

Six roles, each a separate Claude CLI process with its own system prompt and memory slice:

CEO agent — decides scope. This morning's call: "ship Agent Cookbook to Gumroad today, $19, no feature creep."
PM agent — splits the day into six working blocks and assigns deliverables per block.
Copywriter — drafts launch copy. Fires on a red light.
Designer — renders covers and OG images. Runs while I wait at the restaurant counter.
Dev — writes and patches code. Gets the longest turns.
QA — reviews everything the others produce and returns a numbered list of defects.

A seventh helper, the CC Daemon, polls IMAP for 2FA codes, pastes them into forms, and pushes completion notices to Discord so I hear a ping on my helmet speaker.

A real timeline from today

09:40, red light on Dunhua: I Discord-send "cookbook launch — $19 — today." CEO answers in 14 seconds.
11:22, waiting for a bento: Designer drops v1 of the cover. Too busy. I reply with one emoji. v2 lands while I strap the bag.
14:08, left turn on Section 4 of Zhongxiao: QA finds three factual errors in the draft. Dev patches them before the light turns green.
19:55, ringing a customer's doorbell: Gumroad sends a KYC code. CC Daemon reads the email, fills the field, publishes the listing. My phone buzzes: live.

I got home soaked. The product had already made its first sale.

The architecture, end to end

Phone (Discord)
   |
   v
CC Daemon  (hourly tick + event triggers)
   |
   v
Blackboard  (tasks.jsonl — append-only)
   |
   v  fan-out
Subagents  (Claude CLI, parallel)
   - CEO, PM, Copy, Design, Dev, QA
   |
   v
Shared memory  (MemPalace — MCP knowledge graph)
   |
   v
Output queue ---> Gumroad / Discord push / inbox/

The blackboard is the whole trick. Every agent reads the same tasks.jsonl, claims a row, writes its output back as a new row with a parent_id. No orchestrator god-object. If one agent crashes, the row stays unclaimed and the next tick retries it.

MemPalace is the shared brain. When the Copywriter references "last week's tone notes," it's pulling from the same knowledge graph the CEO used to write today's brief. Context survives /compact, reboots, and me forgetting what day it is.

The minimum viable tick

Strip away the Discord bridge, the IMAP poller, the MCP servers, and this is the beating heart:

# Minimal daemon tick — run every 5 minutes via launchd/cron
import subprocess
from pathlib import Path

def call_agent(role_prompt: str, user_prompt: str) -> str | None:
    r = subprocess.run(
        ["claude", "-p", "--max-turns", "1",
         f"[ROLE]\n{role_prompt}\n[TASK]\n{user_prompt}"],
        capture_output=True, text=True, timeout=120,
    )
    return r.stdout if r.returncode == 0 else None

draft = call_agent(
    "You are a copywriter. 200 words max. Hook in first line.",
    "Write a Threads post about shipping while delivering food.",
)
review = call_agent(
    "You are QA. Return a numbered list of factual or tonal defects.",
    f"Review this draft:\n{draft}",
)

Path("inbox/draft.md").write_text(draft or "")
Path("inbox/review.md").write_text(review or "")
# Next tick: a Dev agent reads review.md and patches draft.md.

Fifteen lines. Two agents. A handoff via files. Scale the same pattern to six roles and you have my setup — minus the keys I'm not going to paste.

Why I built it this way

My fixed monthly bills are NT$47,000. I cannot afford one human employee. I cannot afford to stop delivering to "focus on the startup." So I built a team I pay in electricity — less than one coffee a day on an M1 Max — that doesn't clock out when I go back on the road.

The reframe that made it click: I'm not trying to automate myself out of delivery. I'm trying to make sure the six hours I'm on a scooter aren't six hours my business is asleep. Food delivery pays cash today. Agents compound tomorrow. I need both.

What's in the cookbook

I wrote down every piece: the role prompts, the blackboard schema, the Discord-to-daemon bridge, the handoff patterns between CEO and PM, how QA returns structured defects Dev can actually apply, and the failure modes I hit in the first six weeks (there were many).

One honest line: this is a pattern cookbook — you'll wire your own Discord, IMAP, and API keys to make it run. I'm handing you the architecture and the prompts that survived contact with reality, not a one-click installer.

$19 on Gumroad. I'm asleep, on a scooter, or soaked — it's still selling.

https://vampireheart3.gumroad.com/l/agent-cookbook

This is Thursday.