Agent Journal

A repeatable build pipeline: lint, test, and gates in one command

Sun, 16 Aug 2026 00:00:00 +0000

A repeatable build pipeline is one command that runs format, lint, type checks, and tests, and it must fail loudly when any of them break. I used to run those checks by hand and skip them when I was in a hurry, which is exactly when the bugs slipped through. The fix was to collapse the whole check into a single Makefile target that I never run partway. It runs the same everywhere, and I trust it only because it is automated.

About

Sun, 16 Aug 2026 00:00:00 +0000

I’m ikkun — a software engineer who has been running AI coding agents in production, every day, since before it was a job title.

This journal exists because most writing about AI agents is either vendor marketing or “here’s a cool prompt” content. Almost nobody writes about the boring parts: which agent to use for which task, how to wire up MCP servers without breaking your secrets, why your gateway costs doubled, what to do when the agent deletes your .env.

Alpha Vantage limits and the Japanese stock gap

Sun, 16 Aug 2026 00:00:00 +0000

When I first went to wire up a stock data feed, Alpha Vantage looked like the obvious default: it’s free, it’s a real API, and it covers a huge swath of assets. So I wrote my pipeline against it — and then discovered two things that changed how I think about any free financial data feed. First, the free tier is rate-limited so tightly (I measured roughly 5 requests per minute) that any loop needs a sleep between calls. Second, and bigger for me: it doesn’t cover Japanese stocks at all, which is the market I actually needed. Checked and confirmed in my own setup.

API first, scraping second: when official feeds win

Sun, 16 Aug 2026 00:00:00 +0000

When I need data for an agent, I reach for the official API first and treat scraping as the fallback. The direct answer: an official, machine-readable, documented feed wins over a scraper whenever one exists, because it has a stated contract, is more reliable, and avoids bot walls. I only scrape when there is no official API, or when the official one is genuinely insufficient for the job.

Why I default to the API

My rule is simple: official source first, scraping second. It comes from running agents that pull statistics, financial filings, and corporate registry data on a schedule. Those feeds are the difference between a pipeline that runs unattended for months and one I have to babysit.

API key hygiene for LLM calls: headers, proxies, and kill switches

Sun, 16 Aug 2026 00:00:00 +0000

An API key travels in a request header, and once it is inside agent context, it can end up anywhere the agent’s tools reach: transcripts, logs, file writes. The failure I design against is a key that leaks and takes a service down with it. My rules are boring on purpose: keys live in pass or Bitwarden, never in agent context; agents get secrets at runtime through a broker; long-lived keys are the enemy, so I use refresh tokens that rotate, short-lived sessions, and per-service keys scoped to one tool. When a key does leak, the blast radius is one service. That is the goal.

Background processes in automation: nohup is dead, track them properly

Sun, 16 Aug 2026 00:00:00 +0000

The fix for background work that keeps disappearing is to treat every background process as something tracked and polled by session ID, never fire-and-forget with nohup and a trailing &. I stopped using nohup years ago, and the jobs I run no longer vanish. nohup lets you detach a process from the shell, but the moment it is detached from anything that tracks it, that process might as well not exist. A background job is only real if something else knows it is running.

Backup discipline: what I back up, when, and how I prove it works

Sun, 16 Aug 2026 00:00:00 +0000

Backups only earn their keep when you can restore from them, so I apply the same discipline to backups as I do to every other scheduled job. My setup runs a local zip archive at 02:00, syncs an offsite copy to object storage at 02:30, and snapshots the database at 03:05. Nothing in that schedule is special — the point is that it exists, runs every day, and is actually tested.

Batch scraping at scale: hundreds of URLs without drama

Sun, 16 Aug 2026 00:00:00 +0000

Scraping one page at a time is fine until the collection is hundreds of URLs, and then it stops being fine. The fix I run: batch mode with a swarm — submit the whole URL list to a task group, let the browser work through it with bounded parallelism, and write results as resumable JSONL. It turns a session of babysitting into one command that finishes on its own.

Why single-page scraping stops scaling

A single navigation loop works when the job is a handful of pages. Open the browser, go to the URL, snapshot the page, close. Repeat. The problems show up at scale: each run carries per-page overhead, a failure anywhere in the middle forces a restart or manual bookkeeping of what already finished, and the browser itself becomes the bottleneck.

Bridging MCP Servers with mcporter: Ad-Hoc Tools Without Config Changes

Sun, 16 Aug 2026 00:00:00 +0000

My agent config was becoming a collection of servers I barely used. Every MCP server I had ever tried was wired in, and the tool list had grown well past what I actually called on a normal day. The fix I run now is mcporter: a CLI bridge for MCP servers that lets me list, configure, authenticate, and call servers from the terminal — without wiring them into the agent config at all. For ad-hoc interaction with a server that is not worth enabling permanently, I invoke it through the bridge instead of giving it a permanent slot.

Checking Domain Availability with RDAP: No WHOIS, No Rate Limits

Sun, 16 Aug 2026 00:00:00 +0000

To check whether a domain is still available without hitting WHOIS rate limits, I use RDAP. RDAP (the Registration Data Access Protocol) is the modern replacement for WHOIS, and it gives me the answer in a single HTTP request: https://rdap.org/domain/<domain> returns HTTP 404 when the domain is available and HTTP 200 when it is registered. No login, no per-query throttling that breaks my scripts, just a status code. It became my default tool for the first question I ask about any name idea.

Choosing a Registrar: First-Year Prices Are a Trap

Sun, 16 Aug 2026 00:00:00 +0000

First-year promo prices are a trap: the number that looks cheap is almost never the number you pay next year. A concrete example I keep seeing is GoDaddy selling .com at $4.99 for the first year and then renewing at $22.99. The way I actually choose a registrar now is to ignore the first-year number entirely and decide on the renewal price — check both before I commit to anything. A domain is a multi-year commitment, and the renewal price is what you pay for most of that time.

Choosing an embedding model for Japanese text

Sun, 16 Aug 2026 00:00:00 +0000

I learned the hard way that an embedding model that works well on English can quietly fail on my actual documents. I run agents that memorize and retrieve across Japanese text, and when I first wired up retrieval with a generic English model the results were noticeably worse than I expected. The direct answer: match the embedding model to the language of your documents. For Japanese I use a Japanese-optimized embedding model, and the difference in retrieval quality was immediate and reproducible.

Choosing data APIs: coverage, rate limits, and free-tier reality

Sun, 16 Aug 2026 00:00:00 +0000

The short answer: before you build a pipeline on any data API, check three things — coverage, rate limits, and whether an official source exists. I learned this the hard way when a free global stock feed simply had no data for Japanese tickers, and the “free” tier turned out to be tight enough that it throttled a simple loop. Coverage and rate limits decide whether a feed is usable at all; officialness decides whether you should trust it. The decision rule I use now: official plus sufficient plus free beats scraping.

clasp login without a browser: the headless OAuth dance

Sun, 16 Aug 2026 00:00:00 +0000

clasp, the CLI for Google Apps Script, wants to open a browser when you log in — and on a headless server there is no browser to open. The answer I use: authenticate Google CLIs through a device-flow OAuth setup that works without a local browser. The CLI prints a code and a URL, I approve on any device, and clasp picks up the token. After that, clasp can clone and deploy Apps Script projects from a server.

Closing port 22: SSH over Tailscale only

Sun, 16 Aug 2026 00:00:00 +0000

I closed port 22 on my VPS and now reach it only over a Tailscale tailnet. The direct answer: SSH over a tailnet means no public listener, no port 22 exposed to the internet, and the SSH service is reachable only inside a private, WireGuard-based network. My public port 22 has been closed since 2026-08-09, and all of my admin access now happens over the tailnet.

This wasn’t a fashionable hardening trend. It was the conclusion of a longer thread about what I actually want a public server to look like. My agents and dashboards need to be reachable, but my shell does not. SSH is the one service that should exist for exactly one person — me — over a private network that only my devices join.

Context window budgeting: keeping long agent sessions useful

Sun, 16 Aug 2026 00:00:00 +0000

Long agent sessions start sharp and go soft. I have watched this happen enough times to stop fighting it: the session that was crisp at hour one is re-reading its own early output by hour four, and the fix it proposes is subtly worse. The direct answer is that the context window is a scratchpad, not memory, and budgeting it means treating session length as a cost. I now keep sessions scoped to one task, never carry chat history across unrelated work, and restart rather than repair a bloated context.

Controlling agent spend: free tiers, routing, and hard limits

Sun, 16 Aug 2026 00:00:00 +0000

A few months into running agents in production, my monthly spend stopped making sense. I was not doing more work — the bill was drifting up because my routing was lazy. The fix I run today is simple: expensive calls go through genuinely free tiers first, repetitive work gets self-hosted on a small model, and all paid spend flows through one auditable gateway. My whole agent infrastructure runs at roughly $15 a month — one paid gateway at about $10, one small VPS at about $5, and everything else on free tiers. Here is the routing logic, and the failure mode that would push the same setup past $200 a month.

Cosign keyless signing: verifying artifacts without a keypair

Sun, 16 Aug 2026 00:00:00 +0000

Signing releases used to mean guarding a private key for years and hoping it never leaked. I sign release artifacts with cosign keyless signing instead, which means there is no long-lived signing keypair to manage at all. Signatures are created with a short-lived key bound to an identity, and users verify the artifact against that public identity instead of trusting me to protect a key. This post is how the keyless flow fits my release process and why I will not ship a security tool any other way.

Credential Management for AI Agents: What Actually Works

Sun, 16 Aug 2026 00:00:00 +0000

The only credential setup that has held up in my production use is a broker pattern: agents reference secrets by name, and a local broker resolves the real value at the process or transport layer. The agent never holds the plaintext, so it cannot leak what it does not have. Everything else I tried — .env files, exported environment variables, “just be careful” — eventually failed.

The incident that started this

My agent echoed a connection string into tool output. Not once — a few times, on different projects. The pattern is always the same: the agent runs a command, the command prints its environment or a config dump for debugging, and the output lands in the agent’s context window. From there it goes into the transcript, sometimes into logs, sometimes into a chat summary sent to an API endpoint I don’t control.

Cron in JST: timezone pitfalls in scheduled automation

Sun, 16 Aug 2026 00:00:00 +0000

Scheduled automation is timezone-sensitive, and I learned that the hard way after a job scheduled for JST hours fired at the wrong wall-clock time for a week straight. The direct answer: cron runs in the host’s local time, so the fix is to set the cron host timezone explicitly to JST and state the intended local time in the job registry instead of relying on a bare cron expression. Until you do that, your 08:00 job can silently fire at 23:00 UTC or whenever the box happens to think it is.

Datacenter IPs and Bot Walls: HN, Reddit, and dev.to from a VPS

Sun, 16 Aug 2026 00:00:00 +0000

If you run services from a cloud VPS, you will eventually discover that datacenter IP ranges are treated as guilty until proven innocent. My measured results: Hacker News rate-limits aggressively (HTTP 429), Reddit blocks outright, and dev.to sits behind a reCAPTCHA v3 wall that datacenter traffic struggles to pass. The lesson is not “use a VPN” — it is that account creation and community posting are human-network activities, and the network you post from is part of your identity.

Delegating Work to Subagents: What I Learned from a Year of Parallel Tasks

Sun, 16 Aug 2026 00:00:00 +0000

The hardest lesson in delegating to subagents: their reports are self-reports, not verified facts. A subagent that says “uploaded successfully” may have written nothing. A subagent that says “all tests pass” may have run them against the wrong thing. After a year of running parallel agent tasks, the verification loop I put around delegation matters more than any model choice inside it.

Why delegate at all

Independent subtasks — research, drafting, code generation, batch scraping — are the sweet spot for parallel agents. Each one gets its own context, its own terminal, and its own failure mode, and the parent gets one summary instead of a context flood. Done right, a batch of five tasks finishes in the time one would take.

Designing an audit log: append-only, 0600, and SIGHUP rotation

Sun, 16 Aug 2026 00:00:00 +0000

The first version of my credential tooling logged nothing. When something went wrong I had only the exit code and my memory of what I had told it to do, which was not enough to reconstruct a session I had delegated hours earlier. The fix was designing an audit log on purpose rather than letting one happen. The design comes down to three properties: the log is append-only JSONL at a user-state path, it has mode 0600, and rotation works by reopening the file on SIGHUP. Append-only, 0600, and signal-based rotation are the three properties that make a log trustworthy enough to act on.

Designing Emails for Mobile Gmail: Cards, Not Tables

Sun, 16 Aug 2026 00:00:00 +0000

The rule for every automated report email I send: design for mobile Gmail first — card-based layout, single column, no wide tables. I read most of these emails on my phone, and an email that needs horizontal scrolling to read is an email that gets ignored.

The constraint that decides the design

Email clients are a constrained medium: no flexbox reliably, no grid, inline CSS everywhere. Mobile Gmail adds the real constraint — a viewport a few hundred pixels wide. The designs that survive are single-column layouts built from stacked cards, not multi-column tables.

dev.to syndication with canonical URLs: republishing without SEO damage

Sun, 16 Aug 2026 00:00:00 +0000

Republishing your own post on dev.to can split your search rankings, because search engines treat two copies of the same text as duplicate content. I republish my articles on dev.to with a canonical URL pointing back to this site, which tells search engines which copy is the original and keeps the ranking here. The platform post becomes a discovery copy, not a duplicate. It costs me one small step per post, and it has turned republishing from an SEO gamble into a routine.

Disclosure

Sun, 16 Aug 2026 00:00:00 +0000

This page explains exactly how Agent Journal makes money. There are no hidden answers.

Affiliate links

Some posts contain affiliate links. When you click one and buy something, we may receive a commission from the merchant — typically 20–40% of the first month or year for SaaS, less for marketplaces. The price you pay is identical whether or not you use our link.

Affiliate links are used for:

Dev tools and SaaS we actually use (gateways, observability, hosting, domains)
Cloud services and infrastructure
Occasionally, books and hardware

Posts containing affiliate links carry a visible notice at the top, like the one on this site’s article pages.

DNS management on Cloudflare: records, proxies, and TTL choices

Sun, 16 Aug 2026 00:00:00 +0000

When I bound a custom domain to a Cloudflare Pages project, the next job was putting the DNS zone in the same place. The short version: add the zone in the dashboard on the free plan, point the registrar’s nameservers at the two Cloudflare nameservers, wait for the zone status to flip from pending to active, then add the records you need. One thing worth knowing up front — adding a zone is a dashboard operation. With a Pages-only token I could not do it from the CLI or API.

DNSSEC and CAA records: cheap insurance for your domain

Sun, 16 Aug 2026 00:00:00 +0000

DNS is one of the oldest parts of the internet, and for most of its life it could not prove that an answer was genuine. If someone can spoof a DNS response, they can send your visitors — or your agents — to a server they control. The fix is cheap: enable DNSSEC at your registrar, and once your zone is on a managed DNS provider, add CAA records. DNSSEC cryptographically signs DNS responses so spoofing fails verification, and CAA records declare which certificate authorities may issue certificates for your domain. Both are set-and-forget controls, and I run them on the domain behind this site.

Docker security basics: read-only, no-new-privileges, and friends

Sun, 16 Aug 2026 00:00:00 +0000

I run several self-hosted services in Docker, a vector database, my memory layer, and a few dashboards, and the question that kept coming back was how much container flags actually do. The direct answer: the three Docker security flags I rely on are a read-only root filesystem where possible, no-new-privileges, and dropped capabilities. None of them is a wall, but together they shrink the surface a container exposes, and they cost almost nothing to set. This post is what I actually configure and why.

Driving Google Workspace from the terminal: Gmail, Drive, Sheets

Sun, 16 Aug 2026 00:00:00 +0000

Scripts that need to touch Gmail, Calendar, or Drive usually end up with a pile of per-app credentials and browser-only workflows. The setup I run instead: a single CLI (gws) that drives Google Workspace from the terminal — Gmail, Calendar, Drive, Docs, and Sheets. One command line, one auth setup, no browser. It sends mail from scripts, reads my calendar, and handles file operations in Drive without me opening a single Google tab.

EDINET API v2: XBRL filings as CSV without the pain

Sun, 16 Aug 2026 00:00:00 +0000

The problem: Japanese financial filings in a usable shape

If you want annual or quarterly financials for Japanese companies, the filings are real and public, but they sit in XBRL. XBRL is great for regulators and lousy for a quick pipeline: it is verbose, namespaced, and tied to taxonomy dictionaries. My first attempts to pull company financials meant wrestling XBRL documents and their taxonomies into something I could actually compute on. It was painful enough that I kept looking for a shortcut, and the right shortcut is the official one.

Editorial Policy

Sun, 16 Aug 2026 00:00:00 +0000

Short version: everything here is tested by me, in production, before I write about it. No sponsored posts. Affiliate links never change a verdict.

What we write about

Running AI coding agents (Claude Code, Codex, opencode, Hermes) in real workflows
MCP servers, agent tooling, credential management, and LLM gateways
The ops side: automation, self-hosting, monitoring, cost control

We don’t cover tools we haven’t used. If a post mentions a product we have no hands-on experience with, it’s marked as such.

Egress Costs: Where Free Tiers Quietly Stop Being Free

Sun, 16 Aug 2026 00:00:00 +0000

The free tier is not where the bill appears — it is the download that is. Some providers bill egress, the outbound data transfer, and a modest site or backup workload can quietly run up charges you never planned for. Storage looks cheap or free until you move the data out of it. The fix is not exotic: read the egress pricing before committing data volume, and choose storage that does not charge for the move.

Fail2ban: Real Value and False Confidence

Sun, 16 Aug 2026 00:00:00 +0000

Fail2ban is one of the most recommended security tools on the internet, and also one of the most oversold. Here is the direct answer: fail2ban works by parsing authentication logs and adding a temporary ban for repeated failures, and its real value is that it reduces noise from credential-stuffing bots. Its false confidence is believing it is a substitute for key-only SSH and a closed port. I run it, and I monitor it like any other service, and I keep expectations calibrated.

Fallback Chains: What Happens When Your Gateway 429s

Sun, 16 Aug 2026 00:00:00 +0000

A single 429 used to stop every agent I ran. The gateway would return a rate-limit error, the request would fail, and the whole pipeline would sit there until I noticed. The fix was a fallback chain: primary gateway (Merge Pro ) first, OpenRouter second, and a different provider as the final resort when the 429s keep coming. The chain is configured, not improvised — every agent and script knows the order in advance. Since I set that up, a rate limit on one provider slows things down instead of stopping them.

Fresh VPS Hardening: The Order I Actually Use

Sun, 16 Aug 2026 00:00:00 +0000

Every time I provision a fresh VPS I follow the same order, because the order has consequences. I harden SSH first, then set up the firewall, then fail2ban, then automatic updates, and only after all of that do I install the services the box is actually for. If you get a new server and your first move is installing the application, you are setting up an unlocked house and then decorating it. Here is the sequence I run on every fresh box, and why each step comes before the next.

GAS web apps as API proxies: hiding keys at zero cost

Sun, 16 Aug 2026 00:00:00 +0000

Every script that calls an API from the client side ends up holding a key, and a key that ships to a client is a key that can leak. The zero-cost fix I run: a Google Apps Script (GAS) web app as an API proxy. The web app holds the upstream API key server-side and exposes a public endpoint. Clients call the endpoint; the key never appears in any client request. It hides the key, adds a controllable layer, and costs nothing to operate.

GCP free tier: what's actually usable for a hobbyist

Sun, 16 Aug 2026 00:00:00 +0000

Yes, Google Cloud’s free tier is usable for hobby work — I use GCP free-tier resources for specific workloads and for Google-linked automation, and the whole thing costs zero. The realistic answer, though, is narrower than the marketing suggests: it covers a small set of always-free resources, the quotas are tight, and the entire skill is knowing exactly what is free and what bills the moment you exceed it. Get that boundary wrong and the “free tier” quietly stops being free.

Getting Japanese government statistics via the e-Stat API

Sun, 16 Aug 2026 00:00:00 +0000

The problem: where do official Japanese numbers actually live?

Whenever I need population, GDP, CPI, or employment figures for Japan, my first instinct used to be to find some blog or aggregator that had already copied the numbers into a table. That works once, but it breaks the moment the source updates or I need a different slice of the data. Scraped and hand-copied statistics are a maintenance trap: I never know whether what I am reading is current, complete, or even from the official release. I wanted the source itself.

GGUF quantization: how much quality do you lose at Q4?

Sun, 16 Aug 2026 00:00:00 +0000

I spent a long time assuming that running a model locally meant running it the way the authors wrote it, full precision and all that. Then I actually had to run models on the hardware I own, and quantization changed how I think about every model I deploy. The direct answer to the title question: at Q4-class quantization you lose some quality, but for the output I actually consume — embeddings, classifications, structured labels from my agents — the loss is small enough that I accept it routinely. That fact is what makes GGUF worth understanding instead of fearing.

Giving Agents Memory: Self-Hosted Qdrant + Mem0

Sun, 16 Aug 2026 00:00:00 +0000

The way I give agents long-term memory is a small self-hosted stack: a vector database for storage, a Japanese-capable embedding model for indexing, and an open-source memory layer on top. The context window handles the current task; the memory layer handles everything the agent should still know next week. Keeping both local means the agent’s memory never leaves my server.

Why agents need memory at all

A context window is a scratchpad, not a memory. When the session ends, everything it contained is gone — unless something wrote it down. Memory is that something: a layer the agent queries before answering, and updates when it learns something durable.

Headless browser setup that doesn't get you blocked

Sun, 16 Aug 2026 00:00:00 +0000

When an agent needs a page that only exists after JavaScript runs, a plain HTTP request is not enough, and a badly wired headless browser gets blocked before it gets anything. The direct answer: I run a local browser-automation server (browser4) on a fixed port and drive it with a CLI — goto a URL, snapshot the page, close. The server holds one real browser session so consecutive commands share state, and I set generous timeouts because navigation over residential proxies is slow. That setup gets the pages my agents need without the failures I used to chase.

Health checks that match reality: monitoring services you actually run

Sun, 16 Aug 2026 00:00:00 +0000

It is easy to end up with a monitoring setup that watches more than you run, or less. Mine went the other way for a while: I added rules as services appeared and never removed them when services went away, so the dashboard showed green next to checks for things that no longer existed. That taught me the principle I use now: the health check monitors exactly the services that exist, and when a service is removed, its monitoring rule goes with it. My check currently watches seven services — docker, ssh, cron, fail2ban, systemd-journald, logrotate.timer, and unattended-upgrades — and each one is a service I would actually act on if it died.

Hiding API keys behind a Cloudflare Worker: the free proxy pattern

Sun, 16 Aug 2026 00:00:00 +0000

Every client that talks to an API ends up holding a key, and every copy of that key is another place it can leak. The pattern I use to avoid that: hide the key behind a Cloudflare Worker on the free tier. The client calls the Worker. The Worker adds the real key server-side and forwards the request to the upstream API. The client never sees the key, and the Worker URL is the only credential it needs.

How This Site Is Built: Hugo + Cloudflare Pages, Operated by Agents

Sun, 16 Aug 2026 00:00:00 +0000

This site is a demonstration of its own subject matter: an AI agent operates the entire pipeline — topic selection, article generation, compliance scrubbing, deployment, and verification — while a human supplies the experience and makes the decisions. The stack is deliberately boring: Hugo on Cloudflare Pages, a YAML topic queue, and a deploy script. The interesting part is what the agent does around that stack.

The stack

Hugo, single language, custom layouts. Static HTML, no runtime, no database. GitHub-dark styling, mobile-first.
Cloudflare Pages for hosting. Free tier, global edge, HTTPS by default. A .dev domain that enforces HTTPS at the registry level.
A YAML topic queue (seo-topics.yaml) as the editorial system. Every article starts as a topic with an angle — and the angle must be grounded in observable first-hand material, not a keyword list.

The pipeline

Each article moves through the same path:

Hugo on Cloudflare Pages: a free static site stack

Sun, 16 Aug 2026 00:00:00 +0000

This site needed a home with three properties: zero hosting cost, no server to maintain, and HTTPS that never becomes my problem. I run it on Hugo, a static site generator, and Cloudflare Pages on the free tier, and it delivers all three. The entire deploy path is one script that builds the site and uploads it, and since it went up, the hosting layer has not demanded any attention.

Idempotency for scheduled jobs: running twice must not break

Sun, 16 Aug 2026 00:00:00 +0000

A scheduled job fails at 03:00, and the only sane recovery is to run it again. If rerunning it breaks something worse, you have just traded a small failure for a bigger one. The direct answer: design every scheduled job so that running it twice is safe, because re-running a failed job is my primary recovery action. I apply three idempotency patterns: skip work already done, use append-with-dedup, and make the job’s result independent of how many times it ran. A job that cannot be re-run safely forces risky manual intervention at 03:00, and that is the failure mode I refuse to accept.

IRBANK API: Japanese stock data without scraping

Sun, 16 Aug 2026 00:00:00 +0000

If you build anything that tracks Japanese equities, the hardest part is rarely the model or the pipeline — it’s just getting the data. Global free financial APIs mostly ignore the Tokyo market, and scraping exchange sites from my own servers has burned me before (those datacenter IPs get blocked fast, as I wrote in my datacenter-IP notes). The answer I settled on is an IRBANK-compatible API: I pointed my daily job at a REST endpoint, passed a security code, and got clean OHLCV history back without touching a scraper. Here is how I actually use it.

journald is enough: running log infrastructure without rsyslog

Sun, 16 Aug 2026 00:00:00 +0000

A lot of Linux guides assume you need a dedicated syslog daemon. When I set up my agent servers, I checked that assumption and I run systemd-journald and deliberately do not run rsyslog. For my workloads journald is enough, and removing rsyslog removed a daemon I did not want to maintain. This article is the reasoning behind that choice and the pieces that make it work.

Why I stopped treating rsyslog as a default

Rsyslog is fine software. It just did not fit my workflow. The moment I installed a server, the default configuration started a separate syslog daemon writing to files I rarely read, while my actual service logs lived somewhere else entirely. That split never earned its keep on my machines, so I removed it. My servers run systemd-journald as the only log mechanism, and journald itself already does the things I care about.

JSON Output for CLIs: Making Tools Machine-Readable by Default

Sun, 16 Aug 2026 00:00:00 +0000

The design rule I apply to every CLI I build: structured output by default — JSON, ISO dates, integer amounts, and structured errors. Text tables are for humans; JSON is for everything else, and since agents and scripts consume most of my CLI output, the machine-readable form is the default, not an opt-in flag.

Why JSON by default

A CLI that prints a formatted table forces every consumer to parse text — fragile, locale-dependent, and different for every tool. A CLI that prints JSON gives scripts and agents a stable contract: parse once, use everywhere.

kintone from the CLI: Apps, Records, and Automation

Sun, 16 Aug 2026 00:00:00 +0000

kintone — the low-code platform from Cybozu — is manageable entirely from the terminal once you accept its CLI as the interface: app configuration, records, and automation all driven by commands, with credentials in the password store. The author uses it for the same reason as every other CLI in the stack: repeatability, scripting, and agent access.

The setup

The kintone CLI (@kintone/cli) is installed through mise, like every other global tool (see mise tool management). Credentials live in the password store, not in config files or environment dumps — the same credential discipline as the rest of the stack (see credential management).

Lark CLI: OAuth Device Flow, QR Codes, and Session Pitfalls

Sun, 16 Aug 2026 00:00:00 +0000

The Lark CLI is scriptable, but its auth flow has a few traps that cost me an afternoon each: the device-flow login prints a QR code you scan from a phone, a pair of environment variables silently breaks workspace detection, and refresh tokens are single-use with a short life. Once those are understood, the CLI is a reliable piece of the automation stack.

Lark’s OAuth device flow is designed for headless use: run the login with --no-wait, the CLI prints a QR code, you scan it with the Lark mobile app, then complete the exchange with a device-code command. The QR path exists precisely because a browser login is not available on a headless server.

Living on the OpenRouter free tier without hating it

Sun, 16 Aug 2026 00:00:00 +0000

Most free-tier advice reads like a dare: sure, it works, until the day you actually need it. I run a real share of my agent stack — including the LLM calls that keep agent memory current — on the OpenRouter free tier, and it has been fine under daily use. The trick is not hoping the free tier behaves like a paid API. It is routing the right work to it: low-stakes, high-volume calls that can fail quietly and retry, while the critical path stays on the paid gateway.

Logging agent activity: what to record and where

Sun, 16 Aug 2026 00:00:00 +0000

I used to learn what my agents had done by reading their closing summaries. That stopped working the first time an unattended job reported success while producing nothing usable, and I had no way to reconstruct what actually happened. Since then I log agent activity as structured events: an append-only JSONL file at a user-state path with permission 0600, machine-readable and timestamped event types, and a hard rule that entries never contain token values. The log proves what happened without being a leak itself.

Maintaining a fork: tracking upstream while keeping your changes

Sun, 16 Aug 2026 00:00:00 +0000

A fork that never merges upstream becomes a dead end: your copy drifts from the project you forked, and every new upstream feature has to be reinvented by hand. I maintain forks of upstream projects with my own changes on top by merging upstream regularly, keeping my changes isolated, and resolving conflicts deliberately. The rules are simple: track upstream with fetch and merge, keep my own changes in clearly separated commits and branches, and never rewrite shared history.

Managing Dev Tools with mise: No Global Installs, Ever

Sun, 16 Aug 2026 00:00:00 +0000

The rule that keeps my machines reproducible: no global installs outside mise. Every language runtime and global CLI comes from mise, which installs them into a versioned, shim-based environment instead of scattering binaries across the system. npm -g, pip install, and uv tool install are banned as global operations — if a tool is not in mise, it does not exist on my path. That one rule has eliminated most of my environment drift.

Managing repos from the terminal: gh CLI for everything

Sun, 16 Aug 2026 00:00:00 +0000

I manage GitHub repos from the terminal with the gh CLI, and I do not open the web UI for repository work anymore. Auth, repo creation, cloning, issues, and pull requests are all commands. If your workflow still alternates between an editor and a browser for every GitHub action, that is the friction worth removing: gh turns the whole repository lifecycle into shell commands, and the side effect is that scripts and agents can drive GitHub without a browser at all.

MCP explained: why every agent tool talks the same protocol now

Sun, 16 Aug 2026 00:00:00 +0000

Every external tool used to mean a bespoke integration: one calling convention per data source, one glue layer per agent. The direct answer is that MCP (Model Context Protocol) is now the common layer. Servers expose tools, the agent client registers them at setup and calls them during a session, and adding a data source becomes a config change instead of an integration project. My setup runs MCP servers for government statistics, stock data, web search, and scraping, all registered through the same path.

MCP servers: what can go wrong and how to scope them

Sun, 16 Aug 2026 00:00:00 +0000

I stopped treating MCP servers as harmless toolboxes the day I realized everything they return lands in the agent’s context — the same channel a prompt injection uses. The direct answer: treat server output as data, never as instructions; give each server the minimum tool surface it needs; and keep a token rotation routine, because tokens embedded in configs expire. Most MCP failures are not exotic attacks. They are missing scope and expired credentials, and both are preventable.

Mem0 Self-Hosted: Agent Memory Without the Cloud

Sun, 16 Aug 2026 00:00:00 +0000

Agent memory does not have to mean a hosted service. I run Mem0 (open source) self-hosted as the memory layer for my agents, configured against my own LLM endpoint, my own local embeddings, and my own self-hosted vector store. The open-source self-hosted version gives me search, add, update, and delete tooling for agent memory — without sending any of it to the cloud.

Why I wanted the OSS memory layer, not the managed one

Once I committed to keeping my agents’ retrieval local, the managed memory product stopped making sense. The open-source self-hosted version does the job in a way that fits where I already am: my vector database is self-hosted, my embedding model is local, and my LLM endpoint is mine. Mem0 OSS is the layer that sits on top of those and gives the agent-facing operations I described when I wrote about giving agents memory.

Merge Gateway Pro: One API for Daily Models, Cost Tracking Included

Sun, 16 Aug 2026 00:00:00 +0000

My agents used to call model providers directly, and I only found out how much that cost when the invoices arrived. Merge Gateway Pro fixed that for me: one API in front of the models I use daily, with cost tracking built in, for $10/month. It has paid for itself by catching the overspend that direct API calls were quietly running up. The key lives in my pass store, not in agent context, and when Merge is unavailable my calls fall back to OpenRouter.

Migrating Services to Free Tiers: What I Moved and What I Kept

Sun, 16 Aug 2026 00:00:00 +0000

My whole agent stack runs on roughly $15 a month, and that number exists because I deliberately moved most of my services onto free tiers instead of paying for whatever was convenient. The short answer: I migrated almost everything that the free tier genuinely covers, and I kept two things paid — one gateway subscription and one small VPS. Everything else on the bill now has to justify itself.

None of this came from one big cleanup. It came from a repeatable migration order I now apply to any new service before it ever gets a card on file.

Monitoring cron jobs: who notices when the daily job dies

Sun, 16 Aug 2026 00:00:00 +0000

The uncomfortable truth about a daily cron job is that nobody is watching the clock when it runs. A job can die silently - the host wakes up, the wrapper exits non-zero, the mail gets lost - and nothing happens until you happen to look. The direct answer: I keep a registry of every scheduled job, store the operational state separately from the code, hash expected output so unexpected change is detectable, and run a health check over the registered jobs that notifies me on failure. That registry is the single source of truth for what should run, and drift between it and the actual cron table is something I monitor. Here is how that system works.

Multi-agent workflows: orchestrators, workers, and handoffs

Sun, 16 Aug 2026 00:00:00 +0000

The first time I let several agents work on the same task at once, they collided — writing to the same files, duplicating each other’s work, and reporting results that overlapped. The pattern that fixed it is the one I still run today: an orchestrator/worker setup where a parent agent dispatches parallel workers, each worker gets an isolated context and its own terminal session, and workers hand results back to the parent as summaries. Concurrency is capped at up to five parallel workers, and nesting stops at one level: workers cannot spawn their own workers.

Native MCP Client Setup: stdio vs HTTP Servers in Config

Sun, 16 Aug 2026 00:00:00 +0000

I kept flipping servers to enabled in my agent’s config and wondering why nothing changed. The tools were not in the tool list, and I was ready to blame the server. The real answer is simpler: in a native MCP client, servers live in the agent’s config file and their tools appear directly in the agent’s tool list — stdio servers spawn as local processes, while HTTP servers are remote endpoints. And there is one step I kept skipping: after you enable a server, the running client does not pick up the change until you reload it or start a new session. The config edit alone is not enough.

OAuth for CLI tools: device flow, refresh rotation, and long-lived sessions

Sun, 16 Aug 2026 00:00:00 +0000

Every CLI tool that talks to a modern API eventually needs OAuth, and on a headless server the usual browser-based flow quietly fails. The fix is the device flow from RFC 8628: the tool prints a code and a URL, you approve on any device, and the CLI polls until the token arrives. That gets you logged in once. Keeping the session alive for months is a separate discipline around refresh tokens: where they live, whether they rotate, and how you react when they die.

Official data first: why government and exchange APIs beat scrapers

Sun, 16 Aug 2026 00:00:00 +0000

The direct answer: government and exchange APIs beat scrapers because they are official, reliable, contracted, and free from the bot walls that eat scraped pipelines. I run agents that pull corporate filings, statistics, and registry data, and my rule is official sources first — it is the difference between a feed I can trust and one I have to defend. When an official API exists, it wins.

One rule, many sources

My default is not source-specific; it is a habit. Before I build any data pipeline, I ask whether a government or exchange API already exists for the data I need. In practice that turns out true far more often than people expect.

opencode vs Claude Code vs Codex: When Each Wins in My Workflow

Sun, 16 Aug 2026 00:00:00 +0000

I do not have one agent. I match the agent to the task type: opencode for repo-scale work where I want full control of the loop, Claude Code and Codex for specialist sessions, and a separate automation agent for everything that runs unattended. The decision is delegation structure, not model quality — and getting that structure right matters more than which model is behind the agent.

The mistake: picking one agent for everything

When agents first got good, the natural move was to pick one and use it for all work. That fails in two directions: the agent gets used for tasks it is bad at, and the workflow collapses into a single point of failure (one update, one regression, one context disaster takes everything down).

Oracle Cloud free tier: the always-free ARM instance

Sun, 16 Aug 2026 00:00:00 +0000

Yes, Oracle Cloud’s always-free tier really does include a permanently free ARM instance — I run a meaningful part of my agent infrastructure on one. The catch people miss is not the price, it is the availability and the mindset. The free-tier ARM instance hosts agent services and a long-running site in my stack, and it has been genuinely useful. But I treat it as a nearly-free compute resource with a recall clause, not as a permanent home for anything I cannot afford to lose.

pass vs Bitwarden: Running Both, and When Each Wins

Sun, 16 Aug 2026 00:00:00 +0000

I run both pass and Bitwarden, and the split is deliberate. pass (password-store, GPG-encrypted, file-based) is my primary store; Bitwarden holds the entries that live there, accessed through its CLI. The question is not which one to standardize on — it is which store a given secret belongs in. pass wins for anything my agents and scripts touch daily. Bitwarden wins for the entries that were already there and for programmatic access through its API. My credential broker reads both, so there was no migration and no new vault format.

Promoting OSS without spending money: channels that worked

Sun, 16 Aug 2026 00:00:00 +0000

Promoting an open-source project on a zero budget comes down to showing up where developers already read, with posts that solve one problem each. I have promoted my projects without paid ads, sponsorships, or a marketing budget, using dev.to, X, Hacker News, and Chinese community platforms such as V2EX, Zhihu, and Juejin, plus plain community presence. The channels that worked are the ones I could sustain with a fixed cadence and honest KPIs.

Prompt Injection: The Incidents I Actually Hit Running Agents

Sun, 16 Aug 2026 00:00:00 +0000

Prompt injection is not a theoretical risk in my setup — it is the reason my credential architecture exists. The incidents I have actually hit are not dramatic; they are the boring kind: my own agent echoed a connection string into tool output, more than once. And tool output is exactly the channel where injected instructions arrive. The defenses that hold up are structural, not prompt-based.

The incident: secrets in tool output

The pattern is always the same. The agent runs a command — a config dump, an environment print, a debug run — and the command’s output includes a secret value. The output lands in the agent’s context window. From there it goes into the transcript, sometimes into logs, sometimes into a summary sent to an API endpoint I do not control.

Proxy your API keys: the zero-cost pattern that keeps keys off clients

Sun, 16 Aug 2026 00:00:00 +0000

Yes, you can keep API keys off your clients for nothing. The pattern is to hide the key behind a proxy and point every client at the proxy URL instead of the upstream API. The client never holds, sees, or transmits the real key, and because rotation happens in one place, you never redeploy clients when a key changes. It costs nothing on a free tier, and it is the cleanest security win per hour of work I have found.

Qdrant Self-Hosted: Vectors That Never Leave Your Server

Sun, 16 Aug 2026 00:00:00 +0000

My agents’ memory lives in a vector database, and I self-host it in Docker. That is the whole point: the vectors never leave my server. If you have thought about going to a hosted vector service for agent memory but baulked at sending your indexed facts off-box, self-hosting Qdrant is a straightforward alternative that keeps the index on hardware you control.

Why I stopped reaching for a hosted vector store

When I first built the memory layer for my agents, a managed vector database looked easiest: no container to run, no backups to think about, just an API. The more I described my memory setup the clearer it became that the service sitting underneath would be the thing deciding where my agents’ facts physically lived. And the data is the problem. The index holds the durable facts my agents rely on — environment details, conventions, preferences. Sending all of that to a third party for indexing made me uncomfortable, and the more the index grew, the more it felt like the wrong trade.

Quality gates for agent output: verification before merge

Sun, 16 Aug 2026 00:00:00 +0000

Agents produce output that looks finished. That is exactly why I stopped merging anything an agent produces without running it through a gate first. The direct answer: verification happens before merge, and it is automated. My code gate is a Makefile check target that runs format, lint, type-check, and tests, plus pre-commit hooks and a secrets check before commit. For generated content I add word-count, structure, sourcing, and duplication checks, then verify every published URL returns HTTP 200. The gate runs in CI or in the deploy script every time, so verification is a step in the pipeline, not a promise.

R2 for backups: object storage that never bills you for egress

Sun, 16 Aug 2026 00:00:00 +0000

I run my agent infrastructure on a single server, and for a long time my backup plan stopped at “the disk is still fine.” Then I thought through what an actual restore would look like, and egress fees changed the whole calculation. My answer: I use Cloudflare R2 for offsite backups, because R2 never bills for egress. Restoring or downloading backups costs nothing per gigabyte, which makes the one moment you actually need the data — a restore — the cheapest one.

Residential proxies: when your datacenter IP is the problem

Sun, 16 Aug 2026 00:00:00 +0000

Your scraper can be perfect and still get blocked, because the block is often not about your code — it is about where your traffic comes from. The direct answer: when a target discriminates against datacenter ranges, route your browser traffic through a residential proxy. I run a local forwarder on a fixed port that sends browser traffic out through residential IPs, and I keep API-driven work on datacenter IPs, where it belongs.

Retry with exponential backoff: a small library that saves nights

Sun, 16 Aug 2026 00:00:00 +0000

A job fails because a rate limit or a temporary 5xx hiccup comes and goes in a minute. If I bounce up at 03:00 for every transient blip, I never sleep. The direct answer: I keep a small retry helper with exponential backoff in my toolkit, and it decides for me whether a failure is worth another try. On a transient failure it waits a growing amount of time and retries, up to a cap; on a permanent failure it stops immediately. That one small reusable function has quietly saved more nights than any other piece of my automation.

Routing decisions: cheap model first, expensive model on retry

Sun, 16 Aug 2026 00:00:00 +0000

Every LLM call has a price, and the price difference between a small model and a frontier model is large enough to shape the whole budget. The direct answer: I route by task. Cheap model first, expensive model on retry or for high-stakes output. Machine-consumed output, which means embeddings, classification, and extraction, runs on a small dedicated model. Human-read generation runs on a frontier model through a gateway. When the primary gateway returns a 429, a fallback chain moves the request to the next provider, and in one observed case that meant a different model family entirely, not just a different endpoint.

Running Agents Unattended: Cron, Monitoring, and the Notification Loop

Sun, 16 Aug 2026 00:00:00 +0000

The pattern that keeps my unattended agents healthy is boring: every scheduled run goes through a wrapper that logs everything, exits with a code, and notifies a human on failure. Then a separate health check watches the watchers. No dashboard, no pager duty, no AI deciding whether to call me — just a loop that either works silently or makes noise.

Why unattended agents are an ops problem

The moment an agent runs without you watching, it stops being a coding problem and becomes an infrastructure problem. It has a schedule, a runtime, an environment, and failure modes. The interesting failure is not “the agent wrote wrong code” — it is “the job died at 03:00 and nobody noticed for four days.”

Running AI Coding Agents in Production: My 2026 Stack

Sun, 16 Aug 2026 00:00:00 +0000

Everyone has an opinion about AI agents. Almost nobody publishes their actual production setup — the gateways, the MCP servers, the credential handling, the monthly bill. This is mine, as of August 2026, with real numbers and the failures included.

I run coding and automation agents daily for real work: this site, open-source tooling, and the automation that runs my infrastructure. Here’s the stack, layer by layer.

The agents (division of labor)

I don’t use one agent for everything. Using the right tool per task is the cheapest optimization available:

Sandboxing agents: filesystem access and command limits

Sun, 16 Aug 2026 00:00:00 +0000

My agent can read files, write files, run terminal commands, access the web, and drive a browser — and for a long time I treated that as one big permission. The direct answer: stop doing that. Sandboxing an agent is not one enclosure; it is capability separation. File reads, file writes, terminal commands, web access, and browser automation are separate surfaces, each with its own permission handling. Risky operations require explicit human approval, and delegated subagents run in isolated contexts they cannot see out of.

SBOMs in practice: what's in them and who reads them

Sun, 16 Aug 2026 00:00:00 +0000

An SBOM is a machine-readable inventory of every dependency inside your binary, and its practical value only shows up when someone actually reads it. I used to treat software bills of materials as paperwork for large enterprises with compliance teams, not for a solo maintainer. Then I started shipping one with every release of my own project, and the exercise changed how I think about dependencies. Here is what is actually in an SBOM, and who reads it.

Scheduled reporting: turning job output into a readable summary

Sun, 16 Aug 2026 00:00:00 +0000

A scheduled report is only useful if someone actually reads it, so my approach is to aggregate job output into a structured, tight summary and email it on a fixed cadence. I do not send raw logs or long digests. The goal is one screen that answers “what happened since the last report” and nothing more.

Aggregate, don’t forward

The temptation with a scheduled job is to pipe its full output into an email and call it a report. I found that does not work, mainly because nobody reads a wall of text twice. Instead, periodic jobs aggregate their output into a structured report: a compact set of fields that summarize the run — what succeeded, what failed, any values that changed since last time — and that summary is what gets emailed.

Scraping bot-protected pages: CAPTCHA, Cloudflare, and workarounds

Sun, 16 Aug 2026 00:00:00 +0000

Some pages I want to scrape sit behind strong bot protection — Cloudflare challenges, CAPTCHAs — and a plain headless browser fails on them every time. The workaround that works for me is escalation: start with a normal headless browser, add a residential proxy when IP reputation is the problem, and move to a managed scraping browser for the hardest targets. Managed services rotate fingerprints and solve or avoid the challenges themselves, at a per-use cost. Before any of that, I check whether an official API already exists, because many times scraping is the wrong answer.

Scrubbing Secrets from Datastores: Making Bytes Disappear, Not 'Look Deleted'

Sun, 16 Aug 2026 00:00:00 +0000

Deleting a secret from a database is not the same as removing it. A row marked deleted still sits in the file; a rebuilt index still references the old text. The standard that actually works: two-layer redaction — known values plus patterns — then index rebuild and vacuum, so the bytes are gone from the storage layer, not just hidden from the query layer. This is the retroactive half of a credential strategy, and it is the half almost nobody builds.

SEC EDGAR: pulling 10-Ks programmatically

Sun, 16 Aug 2026 00:00:00 +0000

Reading a 10-K by hand every time I need financials is not something an agent should do. The annual report is a wall of text that I mostly want for a few structured facts, and I would rather have a machine fetch and parse it than copy figures from a rendered page. SEC EDGAR is the official repository for US company filings — 10-K, 10-Q, and 8-K — and it is designed to be pulled programmatically. This post is about how I automate 10-K retrieval from EDGAR for analysis.

Secret scanning before commit: pre-commit hooks and CI

Sun, 16 Aug 2026 00:00:00 +0000

The scariest way a credential leaks is quietly, in a commit nobody expects to be interesting. My answer is a secrets check that runs before anything reaches history. The direct version: I run a secrets scan as a pre-commit hook so it catches accidental keys at commit time, and CI runs the same check a second time as a gate. Scanning stops new leaks at the door; scrubbing is a separate problem for what already sits in history. This post is how I wired that and what it realistically covers.

Self-Hosting LLMs: When It Beats the API (and When It Embarrasses You)

Sun, 16 Aug 2026 00:00:00 +0000

The economics of running your own LLM inference are decided by workload shape, not by model quality. Self-hosting — or routing to a small dedicated model — wins for high-volume, low-stakes, repetitive inference: embeddings, classification, extraction, anything where the same kind of call happens thousands of times. Frontier APIs win for quality-sensitive generation. The boundary is measured in tokens per dollar and in what a wrong answer costs, not in vibes.

Sending notification emails from scripts: Resend and friends

Sun, 16 Aug 2026 00:00:00 +0000

When a scheduled job runs and no one hears about it, the job might as well not have run. The direct answer to “how do you send notification emails from scripts” is: route them through an email API such as Resend, triggered from the scheduled job wrapper, where success is quiet or a one-line summary and failure is immediate with the log tail, exit code, and re-run command. The principle I follow is that a notification loop is part of the job — a job that runs but never notifies is already dead.

Session persistence for scrapers: logins that survive restarts

Sun, 16 Aug 2026 00:00:00 +0000

Logged-in sessions do not survive a fresh headless browser — every restart starts anonymous, and pages that need a login fail. The fix I use is a persistent browser profile: keep the profile around between runs so the cookies and session state carry over, and the login survives restarts. I keep one persistent profile for targets that require login, and I keep it strictly separate from throwaway scraping tasks, which run in fresh contexts. The catch is that persistent profiles accumulate state over time, so I refresh them deliberately.

Slack Automation from the Terminal: Messages Without the App

Sun, 16 Aug 2026 00:00:00 +0000

Slack has a CLI story that lets scripts and agents post messages without the app: send to channels from the terminal, driven by cron jobs and pipelines. For a solo operator the value is not chat — it is the notification channel that lands where you already look, without building a webhook integration per script.

Why terminal-first Slack

Slack’s real value for automation is delivery: a message that lands in a channel you already monitor. The pattern: a script finishes (or fails), and a one-line CLI call posts the result. No app, no browser, no per-service webhook plumbing.

Spreadsheet as a database: when Sheets is the right backend

Sun, 16 Aug 2026 00:00:00 +0000

Is a spreadsheet a database? Strictly, no — and for most workloads you should reach for a real one. But I have used a Google Sheet as the data backend for a production tool, and for the right workload it is a legitimate choice: no server to run, no schema migration, and the data stays human-visible and editable. The honest rule is a boundary question. Sheets is the right backend when writes are low, humans review the data, and queries stay simple — and it stops being the right backend the moment concurrency, row count, or query complexity shows up.

systemd unit hardening: sandboxing your services

Sun, 16 Aug 2026 00:00:00 +0000

Every service I run on a server starts from a hardened systemd unit, not a default one. The direct answer: systemd unit hardening is about giving each service the minimal set of privileges its function needs, using directives like NoNewPrivileges, ProtectSystem, and PrivateTmp, and dropping capabilities rather than granting them. I apply this as part of the base configuration for every unit, before an incident, not as a response to one.

Tailscale as Agent Infrastructure: Zero Public Attack Surface

Sun, 16 Aug 2026 00:00:00 +0000

All agent access to my infrastructure runs over a Tailscale tailnet — a WireGuard-based private network — and nothing else. Public port 22 on my server is closed (last verified 2026-08-09), and no agent-facing service listens on a public interface. Agents reach services by tailnet hostname and connect to a tailnet address. The public attack surface for agent access is close to zero, because there is nothing public to attack. If your agents touch real infrastructure, tailnet-only access is the highest-value change I have made.

Testing Methodology

Sun, 16 Aug 2026 00:00:00 +0000

How does a tool end up recommended on Agent Journal? It doesn’t get here by having a good landing page.

The bar

Used in production, not in a demo. The tool has to survive real work: a multi-week project, a production pipeline, an agent that runs unattended. “I ran the quickstart” is not a review.
Minimum two weeks of real use. The first-week honeymoon doesn’t count. Bugs show up in week two, when the tool stops being novel.
Failures are part of the review. If a tool ate my credentials, cost me a night, or lost data — that goes in the post. Every recommendation includes what went wrong and how it was handled.
Compared against the alternatives I actually tried. If I say something is the best gateway for my setup, I say what else I ran and why it lost.
Cost is measured, not estimated. For anything billable, posts include real numbers from my own usage — what the free tier actually covers, what the bill looked like, where the overage came from.

What gets excluded

Tools I haven’t used hands-on (marked explicitly when mentioned)
Tools I used once and couldn’t reproduce
Anything where the vendor’s sales process replaced my testing

Disclosure of conflicts

I maintain open-source software in this space (trustless). If a post touches a competing product, that’s disclosed inline. Affiliate relationships are disclosed on every affected post — see the disclosure.

The .dev TLD: HTTPS by default and what it means

Sun, 16 Aug 2026 00:00:00 +0000

HTTPS on a normal domain is something you configure, and configuration can be forgotten: a link that starts with http://, a subdomain without a certificate, a first request that happens before the redirect. The .dev TLD removes that whole class of mistakes. .dev is a Google Registry TLD with HTTPS enforced — the entire TLD is on the HSTS preload list, so browsers refuse plain HTTP for any .dev domain. In practice that means no mixed-content accidents, no accidental plaintext traffic, and any hosting you point a .dev domain at must provide TLS. For a developer-facing site, that is a feature, not a constraint.

The $15/Month Agent Stack: Free Tiers That Actually Work

Sun, 16 Aug 2026 00:00:00 +0000

My entire agent infrastructure — coding agents, automation, this site, memory, and backups — runs on roughly $15/month, and most of that is one paid gateway subscription. The rest is free tiers that hold up under real use. The trick is not finding free things; it is routing each workload to the tier where it is genuinely free, and keeping the paid spend in one auditable place.

The actual bill

Layer	Cost	What it covers
Gateways	~$10/mo	One paid gateway subscription; free tiers on two others
DNS, hosting, edge	$0	Cloudflare free tier: DNS, Pages (this site), Workers
Compute	~$5/mo	One small VPS for self-hosted services
Domains	~$1/mo amortized	Promotional first-year registrations
Total	~$15/mo

The same setup, with lazy routing, easily runs $200+/month. The difference is where the calls land.

The corporate number API: looking up any Japanese company

Sun, 16 Aug 2026 00:00:00 +0000

When an agent needs to confirm that a company name in my notes is the real, registered entity, guessing from the name alone is not good enough. Names get romanized differently, subsidiaries share prefixes, and two firms can look alike on paper. The answer is the houjin-bangou (法人番号) API, Japan’s official corporate number lookup, and it identifies any registered company from its corporate number. This post is about how I wired it into my data pipeline for resolving and enriching entity data.

The cron wrapper pattern: run.sh, logging, and exit codes

Sun, 16 Aug 2026 00:00:00 +0000

The problem with a cron job is that the moment it matters, you are not looking at it. Cron runs quietly, mails are easy to miss, and a job that fails at 03:00 leaves no sign until you go hunting for it. The direct answer: I route every scheduled task through a wrapper script instead of pointing cron at the tool directly, and the wrapper does three things - it logs everything, it returns a real exit code, and it fails loud. That small indirection is what turns an invisible job into one I can actually operate. Here is how the pattern works and why I run all my scheduled automation through it.

The Entire Cloudflare Free Stack: Pages, Workers, R2, DNS

Sun, 16 Aug 2026 00:00:00 +0000

Yes, the whole stack is actually free: DNS, Pages for static hosting, Workers for edge code, and R2 for object storage all have a genuinely usable free tier, and I run this site on it. DNS, Pages, edge cache, and HTTPS all sit on Cloudflare at zero cost. The free tier here is not a prototype tier — it holds up for a production site. The catch is understanding the usage floors on each product so you stay inside them.

The MCP servers I run daily (and why)

Sun, 16 Aug 2026 00:00:00 +0000

The question I get most often about MCP is not how the protocol works but what to actually run on it. The direct answer for my setup: two servers run always-on — a general web search/fetch server used for most research queries, and a scraping/SERP server for Google results, site: operators, and bot-protected pages — while a batch of specialized servers stay disabled by default and are enabled on demand. The rule behind every choice is context cost versus convenience.

The PR lifecycle: branch, CI, review, merge without the web UI

Sun, 16 Aug 2026 00:00:00 +0000

The pull request is where my changes get reviewed, and for a long time it was also the point where I left the terminal. Branching, committing, and pushing were commands; opening the PR, watching CI, and merging meant a browser. The fix was to drive the entire lifecycle from the CLI: branch, commit, open, CI runs, review, merge — each step a command, none of them requiring a web page.

Transferring domains to Cloudflare Registrar: the 60-day wait

Sun, 16 Aug 2026 00:00:00 +0000

I register domains wherever the first-year deal is cheapest, and I move them to Cloudflare Registrar once the promotional period has done its job. The thing that slows that plan down is the 60-day lock: ICANN blocks transfers for 60 days after a new registration, so a fresh domain cannot be moved no matter which registrar you want to take it. The wait is not a Cloudflare rule — it applies everywhere. Plan around it: register early, wait out the lock, then transfer. The transfer itself takes only a few days.

Trilingual READMEs: EN/JA/ZH as a default for OSS

Sun, 16 Aug 2026 00:00:00 +0000

Every open-source project makes the same silent decision before anyone reads a line of code: which readers is the README allowed to reach? Write it in one language and you have assumed your audience lives in that language. My answer is to ship READMEs in English, Japanese, and Chinese as the default for my open-source projects. A dev tool draws users from all three language communities, and a README in one language quietly excludes the other two. This post is why trilingual became my default and how I keep three files from drifting apart.

Unattended upgrades: letting the server patch itself

Sun, 16 Aug 2026 00:00:00 +0000

The scariest sentence in server administration is “I will patch that this weekend.” It is also the one I stopped believing. My servers run unattended-upgrades to apply security updates automatically, and I keep it enabled and monitor it as a service. Letting the server patch itself beats trusting me to remember a manual window, and this article is about the trade-off I made to do it.

The risk model that changed my mind

Automatic patching looks reckless until you write down what it is actually trading. The deal is simple: automatic patching trades a small risk of breakage for closing known-vulnerability windows promptly. On the other side of the ledger, a server that never patches quietly accumulates known holes that anyone with the right CVE list can exploit.

Vercel AI Gateway free tier: $5 of credits, real limits

Sun, 16 Aug 2026 00:00:00 +0000

“Free tier” on a gateway usually means one of two things: a meter you discover after the bill, or a teaser that evaporates the moment you enter a card. The Vercel AI Gateway free tier is neither — it is $5 of credits per 30 days, real and observed, with no card required. The catch is that the free credits stop once a card is registered. I use it for the projects already on Vercel’s stack, and it works fine as long as I respect that one rule and keep the gateway off the default path.

vLLM for One-Person Inference: Serving a Small Model Properly

Sun, 16 Aug 2026 00:00:00 +0000

vLLM is the serving engine I use for the local models in my stack, and the honest summary is this: for one person running a small Japanese-optimized model for embeddings and light inference, vLLM gives you high-throughput, continuously batched serving that you can point at and forget — once you treat the model as a service instead of a script. The hard part is not starting vLLM. It is remembering that a served model now needs monitoring, restarts, and version pinning, just like anything else you run.

What coding agents actually do (and don't)

Sun, 16 Aug 2026 00:00:00 +0000

The marketing makes coding agents sound like they replace your whole engineering team. Mine don’t. After running them in production for a while, the honest answer is this: a coding agent is software that reads your code and config, calls tools (terminal, file read/write, search), and iterates in a loop of write, run, check, fix. That loop is the whole product. Everything else — autonomy, reasoning, “understanding your codebase” — is a consequence of how well that loop is structured.

wrangler from the terminal: Pages deploys without the dashboard

Sun, 16 Aug 2026 00:00:00 +0000

Deploying through the Cloudflare dashboard means opening a browser, clicking through panels, and repeating the same steps for every release — and none of it can be scripted. I deploy Pages projects with wrangler, the CLI for Cloudflare , and the dashboard has not been part of my release path since. Three commands cover project creation, deploys, and auth checks, and the terminal workflow is the same whether I run it or an agent does.

Agent Journal

A repeatable build pipeline: lint, test, and gates in one command

About

Alpha Vantage limits and the Japanese stock gap

API first, scraping second: when official feeds win

Why I default to the API

API key hygiene for LLM calls: headers, proxies, and kill switches

Background processes in automation: nohup is dead, track them properly

Backup discipline: what I back up, when, and how I prove it works

Batch scraping at scale: hundreds of URLs without drama

Why single-page scraping stops scaling

Bridging MCP Servers with mcporter: Ad-Hoc Tools Without Config Changes

Checking Domain Availability with RDAP: No WHOIS, No Rate Limits

Choosing a Registrar: First-Year Prices Are a Trap

Choosing an embedding model for Japanese text

Choosing data APIs: coverage, rate limits, and free-tier reality

clasp login without a browser: the headless OAuth dance

Closing port 22: SSH over Tailscale only

Context window budgeting: keeping long agent sessions useful

Controlling agent spend: free tiers, routing, and hard limits

Cosign keyless signing: verifying artifacts without a keypair

Credential Management for AI Agents: What Actually Works

The incident that started this

Cron in JST: timezone pitfalls in scheduled automation

Datacenter IPs and Bot Walls: HN, Reddit, and dev.to from a VPS

Delegating Work to Subagents: What I Learned from a Year of Parallel Tasks

Why delegate at all

Designing an audit log: append-only, 0600, and SIGHUP rotation

Designing Emails for Mobile Gmail: Cards, Not Tables

The constraint that decides the design

dev.to syndication with canonical URLs: republishing without SEO damage

Disclosure

Affiliate links

DNS management on Cloudflare: records, proxies, and TTL choices

DNSSEC and CAA records: cheap insurance for your domain

Docker security basics: read-only, no-new-privileges, and friends

Driving Google Workspace from the terminal: Gmail, Drive, Sheets

EDINET API v2: XBRL filings as CSV without the pain

The problem: Japanese financial filings in a usable shape

Editorial Policy

What we write about

Egress Costs: Where Free Tiers Quietly Stop Being Free

Fail2ban: Real Value and False Confidence

Fallback Chains: What Happens When Your Gateway 429s

Fresh VPS Hardening: The Order I Actually Use

GAS web apps as API proxies: hiding keys at zero cost

GCP free tier: what's actually usable for a hobbyist

Getting Japanese government statistics via the e-Stat API

The problem: where do official Japanese numbers actually live?

GGUF quantization: how much quality do you lose at Q4?

Giving Agents Memory: Self-Hosted Qdrant + Mem0

Why agents need memory at all

Headless browser setup that doesn't get you blocked

Health checks that match reality: monitoring services you actually run

Hiding API keys behind a Cloudflare Worker: the free proxy pattern

How This Site Is Built: Hugo + Cloudflare Pages, Operated by Agents

The stack

The pipeline

Hugo on Cloudflare Pages: a free static site stack

Idempotency for scheduled jobs: running twice must not break

IRBANK API: Japanese stock data without scraping

journald is enough: running log infrastructure without rsyslog

Why I stopped treating rsyslog as a default

JSON Output for CLIs: Making Tools Machine-Readable by Default

Why JSON by default

kintone from the CLI: Apps, Records, and Automation

The setup

Lark CLI: OAuth Device Flow, QR Codes, and Session Pitfalls

The login flow that actually works

Living on the OpenRouter free tier without hating it

Logging agent activity: what to record and where

Maintaining a fork: tracking upstream while keeping your changes

Managing Dev Tools with mise: No Global Installs, Ever

Managing repos from the terminal: gh CLI for everything

MCP explained: why every agent tool talks the same protocol now

MCP servers: what can go wrong and how to scope them

Mem0 Self-Hosted: Agent Memory Without the Cloud

Why I wanted the OSS memory layer, not the managed one

Merge Gateway Pro: One API for Daily Models, Cost Tracking Included

Migrating Services to Free Tiers: What I Moved and What I Kept