TinyFish | Rina Takahashi

Rina Takahashi

CURRENT

A journal for living in the agentic age

Practitioner's Corner

Writer Header

Recent Activity

June — Issue #35

The Furniture Is Arriving Before the House Is Built

The Furniture Arrives

The Furniture Is Arriving Before the House Is Built

Agent ecosystem governance and admin infrastructure is arriving because operational practice hasn't settled yet, making the boring stuff unexpectedly urgent.

The OTel GenAI Spec Has an Implicit Reader

The OTel GenAI Spec Has an Implicit Reader

The OTel GenAI semantic conventions reveal how observability built for developer debugging leaves accountability gaps where enterprise adoption stalls.

The Checkbox That Can't Testify

The Checkbox That Can't Testify

Money Complains in Structured Formats

Mechanics and Money

Money Complains in Structured Formats

Rina Takahashi

Rina Takahashi, 37, is an enterprise AI writer and former operations engineer who spent years building web-facing automations for marketplaces and travel platforms. Growing up in her family's ryokan in Nagano, she learned early that the "long tail" of the web represents real businesses trying to survive. After managing 100+ concurrent geo-specific web sessions with on-call rotation and designing failure domains that reduced incident blast radius by 60%, she joined TinyFish to write about web-agent infrastructure with the perspective of someone who's worn the pager: concrete, testable, logged.

Payment networks are building agent-recognition infrastructure because chargebacks demand structured records that separate action from authorization.

The Click Was Never Simple

Mechanics and Money

The Click Was Never Simple

Playwright's auto-waiting spec reveals five preconditions for a single click, each a codified failure mode humans resolve without noticing.

Money Makes Agents Legible

Money Makes Agents Legible

What a Click Carries

Central Idea Piece

What a Click Carries

When agents perform clicks, the implicit human signals the web always assumed vanish, cascading into identity, authorization, and judgment gaps across infrastructure.

June — Issue #34

The Agent That Can't Phone Home

The Agent That Can't Phone Home

Retry Logic Assumes a Contract That LLM Agents Can't Keep

Retry Collision

Retry Logic Assumes a Contract That LLM Agents Can't Keep

Retry logic depends on determinism, but LLM agents make different decisions each attempt, breaking idempotency at the orchestration layer.

Four Checks Before a Click

Four Checks Before a Click

The Screen Scraping Cycle

The Standard and the Cycle

The Screen Scraping Cycle

Across four decades, every generation declared screen-level automation temporary. Every time, the workaround became infrastructure.

The Standard and the Cycle

How a browser testing standard's spec language quietly became the operational vocabulary for AI agents on the live web.

The Thread That Runs Through the Browser

The Testing Substrate

The Thread That Runs Through the Browser

Browser automation's twenty-two-year arc traces a single assumption, built for testing known answers, now carrying agents that have none.

The Context Window Fills Up Long Before It's Full

Conceptual Piece

The Context Window Fills Up Long Before It's Full

Context engineering treats the window as working memory, but nobody measures how token strategy and reliability interact over session length.

Where the Snapshot Lives Changes Everything Else

Tool Architecture Study

Where the Snapshot Lives Changes Everything Else

Playwright's MCP and CLI modes split browser state between context window and disk, with compounding consequences for cost, debugging, and auditability.

When the Meter Starts Running

When the Meter Starts Running

June — Issue #33

The Wall That Used to Be There

Enforcement Gap

The Wall That Used to Be There

Capability improvements quietly removed the constraints that used to kill runaway agents, and enforcement infrastructure hasn't caught up yet.

APIs for Websites That Don't Have APIs

Builder Profile

APIs for Websites That Don't Have APIs

How one founder's marketplace operations background shaped a web agent company built around infrastructure reliability, not AI novelty.

The Accessibility Tree Wasn't Built for AI Agents

Perception Walkthrough

The Accessibility Tree Wasn't Built for AI Agents

Playwright MCP bets that semantic structure beats pixels for agent perception. The token savings are real, but so are the gaps.

The Organizational Inheritance

Two Kinds of Debt

The Organizational Inheritance

RPA's governance lessons were hard-won and well-documented. The teams deploying AI agents today are largely building without that institutional memory.

The Operational Inheritance

Two Kinds of Debt

The Operational Inheritance

Two decades of browser automation taught engineers to distrust the gap between command and outcome. Web agents inherited the gap and every failure mode it produces. The skepticism didn't transfer.

The Confused Deputy Keeps Getting Promoted

The Oldest Deputy

The Confused Deputy Keeps Getting Promoted

Traces how ambient authority created the same vulnerability across four decades, and why LLM agents make the inherited fix harder.

June — Issue #32

Shuchang Zheng and the Architecture That Notices

Builder Profile

Shuchang Zheng and the Architecture That Notices

Skyvern's compile-to-code architecture was built for cost and speed, but its heal step accidentally produces timestamped environmental evidence.

What a Website Chooses to Tell an Agent

WebMCP Walkthrough

What a Website Chooses to Tell an Agent

When a website publishes structured tool definitions for browser agents, it publishes a selective model of itself that the agent inherits as truth.

Where You Can Afford to Be Surprised

The Control Question

Where You Can Afford to Be Surprised

Choosing where the model picks the next step is a risk-tolerance decision that reshapes how failures look, debug, and get explained.

What the Bill Can't Measure

The Meter Drops

What the Bill Can't Measure

GitHub Copilot's shift to metered billing gives organizations cost visibility for the first time, while output correctness remains structurally unmeasured.

The Distance Between Breaking and Fixing

The Severed Loop

The Distance Between Breaking and Fixing

Each workaround built by the people suffering breakage insulates the people causing it, compounding the distance between failure and fix.

June — Issue #31

What Browser Agents See Before They Think

The Perception Layer

What Browser Agents See Before They Think

How browser agents represent web pages to themselves silently determines their reliability, cost, and failure modes before any reasoning begins.

Between Complete and Correct

Builder Profile

Between Complete and Correct

Browser Use's CDP migration and unsolved replay problem trace the gap between agents that finish tasks and agents that finish them correctly.

Retries Were Built for a Deterministic World

Reliability vs. Correctness

Retries Were Built for a Deterministic World

Retry logic assumes the operation it repeats is identical each time. Nondeterministic agents break that assumption, turning reliability into the source of failure.

The Question That Keeps Getting Deferred

The Identity Thread

The Question That Keeps Getting Deferred

Each era's identity mechanism assumed a simpler caller than the last. AI agents are the first caller that reverses that assumption.

The Data Perimeter Split Both Architectures in Half

The Perimeter Problem

The Data Perimeter Split Both Architectures in Half

Enterprise agents split across trust boundaries separate governance from reasoning, and neither architecture resolves who's accountable.

May — Issue #30

Where Intelligence Lives in Each Step

The Autonomy Dial

Where Intelligence Lives in Each Step

The most consequential design choice in browser automation is deciding where each step needs model intelligence and where determinism suffices.

The CAPTCHA Arms Race

Broken Assumptions

The CAPTCHA Arms Race

Every generation of CAPTCHA encoded a confident assumption about the human-machine boundary. Every assumption eventually broke. The pattern continues.

Flaky Tests and the Prehistory of Agent Unreliability

Broken Assumptions

Flaky Tests and the Prehistory of Agent Unreliability

A decade of coping with flaky browser tests built infrastructure for environmental chaos. Agents reintroduce non-determinism where those tools can't reach.

The Same Gap, Three Times

The Recurring Bargain

The Same Gap, Three Times

Three generations of automation, from mainframe screen scraping to RPA to AI browser agents, each broke the same way for the same structural reason.

What a Required Field Knew

The Headless Shift

What a Required Field Knew

Enterprise software going headless for agents strips away the UI layer that silently encoded organizational governance, and rebuilding that specification is harder than most organizations expect.

The Instruments Before the Agents

The Web's Second Layer

The Instruments Before the Agents

Parag Agrawal's architectural choices at Parallel Web Systems reveal what it takes to make the web legible to agents.

May — Issue #29

Every Agent Framework Is an Argument About What's Hard

Choosing the Scaffold

Every Agent Framework Is an Argument About What's Hard

Agent orchestration frameworks encode different control philosophies; matching your system's dominant constraint to the right abstraction beats any feature comparison.

What a Benchmark Score Actually Contains

Reading the Leaderboard

What a Benchmark Score Actually Contains

Agent benchmark scores reflect scaffold and token-budget choices as much as model capability, making them more useful when read as system evaluations.

When Should an Agent Stop Thinking?

The Autonomy Boundary

When Should an Agent Stop Thinking?

Skyvern's architecture compiles LLM reasoning into deterministic scripts, treating intelligence as a compilation step that should diminish over time.

The Architecture of Foregone Conclusions

The Anchor Argument

The Architecture of Foregone Conclusions

Temporary infrastructure choices are calcifying into permanent architecture faster than governance can respond, and the window for intentional design is closing.

The Specification Nobody Read Twice

The Rediscovery

The Specification Nobody Read Twice

Technical knowledge encoded in rejected vocabulary becomes unreachable, making rediscovery structurally inevitable when new communities rebuild what BPEL already formalized.

When Infrastructure Writes the Spec

Specification by Default

When Infrastructure Writes the Spec

Organizations that haven't defined what agent success means are quietly letting infrastructure defaults write that definition for them.

May — Issue #28

What Happens Between MCP and A2A

Protocols in Practice

What Happens Between MCP and A2A

A practical walkthrough of the handoff point where MCP's schema-driven tool calls end and A2A's stateful agent negotiation begins.

Rendering as Identity

Fictions of State

Rendering as Identity

When cookies became blockable, the industry turned browser rendering quirks into identity markers, building on signals that were never stable.

A Shopping Cart's Long Shadow

Fictions of State

A Shopping Cart's Long Shadow

How a 1994 shopping cart fix became so load-bearing that a trillion-dollar company spent six years failing to remove it.

What Suchintan Singh Found When He Left ML Platforms for the Open Web

Builder Profile

What Suchintan Singh Found When He Left ML Platforms for the Open Web

A builder profile tracing how one ML engineer's shift to browser automation revealed that most of the engineering hours go to the infrastructure around the AI.

The Body Problem

The Body Problem

The Body Problem

Agent failures blamed on model reasoning often originate in infrastructure identity rejection, where environments serve poisoned data that no diagnostic framework can surface.

Why Oversight Feels Like Loss

Why Oversight Feels Like Loss

Shifting from doing work to overseeing AI replicates a familiar loss of craft identity that better training alone cannot resolve.

Where Meaning Hides Inside Work

Where Meaning Hides Inside Work

Workers' resistance to automating enjoyable tasks reveals where meaning lives in work and where agent deployment will meet friction.

May — Issue #27

Who Decides Which Model Handles What

Routing In Practice

Who Decides Which Model Handles What

Routing configuration quietly reveals who actually controls your agent stack, often before operators ever see a setting.

The Web Wasn't Built for This

Builder Profile

The Web Wasn't Built for This

Browser Use's 81K stars reveal the brutal gap between making an LLM click a button and making it reliable.

The Wrong Layer

The Wrong Layer

The Wrong Layer

Prompt injection lives in the page. Defenses concentrate where results are shippable, leaving the actual attack surface largely unaddressed.

The Platform Without an Audience

What Breaks Next

The Platform Without an Audience

When your customer is software, ads, loyalty programs, and storefronts lose their audience. What's left?

The Liability Vacuum

What Breaks Next

The Liability Vacuum

Agents can spend money but can't be sued. The accountability framework is still a draft while commerce rolls forward.

The Successor Trap

Blind Spots and Inherited Frames

The Successor Trap

Every proposed successor to robots.txt inherits its core assumption—and the conflict that assumption cannot see.

The Invisible Agent

Blind Spots and Inherited Frames

The Invisible Agent

A 1994 protocol governs web access by reading labels. The new AI agents aren't wearing any.

The Bargain That Held for Thirty Years

The Sign in the Forest

The Bargain That Held for Thirty Years

Robots.txt worked because crawlers returned what they took. AI broke that bargain, and no protocol fixes misaligned incentives.

April — Issue #26

What Meta Found When It Sent Agents Into Its Own Codebase

Builder Profile

What Meta Found When It Sent Agents Into Its Own Codebase

Meta built a 50-agent swarm to excavate its own tribal knowledge and discovered that the real bottleneck was knowledge that had never been written down.

The Legibility Bottleneck

The Formalization Problem

The Legibility Bottleneck

Agents run on the documented version of your organization. The documented version has never been the real one.

Where Will the Thinking Actually Happen?

Still Running / Edge Cases

Where Will the Thinking Actually Happen?

On-device AI promises to redistribute intelligence from the cloud. The economics suggest both layers expand simultaneously.

The Load-Bearing Layer Nobody Talks About

Still Running / Edge Cases

The Load-Bearing Layer Nobody Talks About

Computing's center never actually shifted. Mainframes sank beneath visibility and became the floor everything runs on.

What Happens When the Sandbox Costs More Than the Work Inside It

The Practical Lens

What Happens When the Sandbox Costs More Than the Work Inside It

When agent tasks last milliseconds, the cost of spinning up each sandbox can dwarf the work inside it.

Why Agent Infrastructure Starts Empty

The Conceptual Anchor

Why Agent Infrastructure Starts Empty

Agent infrastructure inverts cloud's oldest assumption: start empty, authorize deliberately, because model-generated code can't be trusted first.

The Governance Layer Land Grab

The Control Plane

The Governance Layer Land Grab

Six vendors shipped agent governance platforms the same month. The real contest is which stack layer owns the enterprise relationship.

April — Issue #25

Why Better Agents Fail More Quietly

The Helpfulness Trap

Why Better Agents Fail More Quietly

Agents optimized to complete tasks will guess rather than stop, and every capability upgrade makes the guessing quieter.

The Gold Medal and the Clock

The Measurement Divergence

The Gold Medal and the Clock

AI systems win gold medals and flunk clock-reading. The Stanford data suggests peak capability and deployment readiness may be diverging, not converging.

When the Web's Visitors Start Buying

The Second Front Door

When the Web's Visitors Start Buying

The web built infrastructure for visitors that read. Its new visitors spend.

OpenClaw's Diary Timeline and the Line Between Transparency and Control

The Concrete Case

OpenClaw's Diary Timeline and the Line Between Transparency and Control

OpenClaw's new memory UI lets you watch an agent decide what to remember, but not why it chose.

What the Pendulum Leaves Behind

What the Pendulum Leaves Behind

Every swing of the rendering pendulum deposits frameworks that never leave. jQuery, AngularJS, Webpack: the weight only accumulates.

Dead Engines Stay Dead

Dead Engines Stay Dead

Browser engine diversity only decreases. The mechanism that killed Presto and EdgeHTML is still running, and accelerating.

April — Issue #24

Why Agent Failures Keep Getting Blamed on the Model

The Context Gap

Why Agent Failures Keep Getting Blamed on the Model

Agent deployments keep failing because nobody owns the context that made the demo work.

Drop-Downs That Aren't Really Drop-Downs

The Self-Orienting Agent

Drop-Downs That Aren't Really Drop-Downs

Browser automation keeps breaking against the web's tacit complexity. Orientation is what scripts were never built for.

Where Agentic AI's 40% Failure Rate Actually Lives

Where Agentic AI's 40% Failure Rate Actually Lives

Massive capital bets and individual deployment math run on different economic logic, and the gap is where projects die.

Trust by Design

Chokepoints and Consequences

Trust by Design

BGP hijacks aren't exploits. They're a trust-based protocol working exactly as designed, in a world it never anticipated.

The HTTPS Exception

Chokepoints and Consequences

The HTTPS Exception

The web's security upgrade required a rare coincidence of concentrated power. Internet routing has no equivalent bottleneck.

Why the Internet Still Trusts Strangers

The Napkin Protocol

Why the Internet Still Trusts Strangers

A 1989 napkin sketch still routes the global internet, and every patch makes replacing it harder.

April — Issue #23

The Agent Toolchain Is Consolidating in Four Different Directions at Once

Where Winners Emerge

The Agent Toolchain Is Consolidating in Four Different Directions at Once

Four layers of the agent toolchain are emitting four structurally different consolidation signals, and reading them matters more than picking winners.

The Same Narrow Water

Rights and Routes

The Same Narrow Water

From Victorian telegraph wire to fiber optic glass, the world's data still squeezes through the same contested straits.

Why American Fiber Follows the Railroad

Rights and Routes

Why American Fiber Follows the Railroad

Nineteenth-century land grants quietly determined where America's internet runs today. Legal permissions outlast every technology they carry.

60 Hudson Street and the Persistence of Place

The Inherited Topology

60 Hudson Street and the Persistence of Place

Telegraph tubes from 1930 now carry fiber optic cable because in communication networks, signals change but geometry persists.

One Production Failure, Thirty Scenarios, and the Debugging Infrastructure That Didn't Exist

The Forensics Problem

One Production Failure, Thirty Scenarios, and the Debugging Infrastructure That Didn't Exist

Veris AI built an entire forensic chain just to answer one question about agent failures. The sophistication of that pipeline says something about how little debugging infrastructure exists.

The Agent's Alibi

The Attribution Gap

The Agent's Alibi

When agent workflows fail, every component can absorb blame, so the agent's own emergent reasoning never faces scrutiny.

March — Issue #22

What Doesn't Survive the Trip Tells You Something About Agents

Portability, Tested

What Doesn't Survive the Trip Tells You Something About Agents

GitAgent's portability bet reveals where agent identity cleanly separates from execution, and where framework-specific cognition resists abstraction.

The Export File Is Not the Agent

The Portability Gap

The Export File Is Not the Agent

Portability tools move agent logic cleanly but leave behind memory, credentials, and trust, revealing what agents actually are.

The Problem You Can Count

The Immune Response

The Problem You Can Count

The agent ecosystem patched what it could count while the messier barriers to production deployment stayed quietly, stubbornly uncountable.

Who Clicks Authorize

Persistence and Proof

Who Clicks Authorize

OAuth's authorization flow assumes someone is there to click "Authorize." Agents broke that assumption.

The Session Assumption

Persistence and Proof

The Session Assumption

Web sessions were built around humans who walk away. Agents never leave the chair.

Sumeet Vaidya and the Distance Between Writing Code and Shipping It

The Builder Profile

Sumeet Vaidya and the Distance Between Writing Code and Shipping It

Sumeet Vaidya built Crafting to close the gap between AI-generated code and what production environments actually accept.

March — Issue #21

Every Layer Works. Nobody Owns the Outcome.

The Stratification Problem

Every Layer Works. Nobody Owns the Outcome.

NVIDIA, Google, and Visa each govern their layer of the agent stack. The outcome spanning all three belongs to nobody.

Building Browser Agents for a Web That Fights Back

Building for Breakage

Building Browser Agents for a Web That Fights Back

Two failed startups taught Skyvern's founders that browser automation keeps breaking because the web actively resists it.

The Clock Everyone Can See

Permanent Decisions

The Clock Everyone Can See

A well-understood timestamp overflow approaches in twelve years, yet billions of devices remain structurally beyond repair.

The Fifty-Year Byte

Permanent Decisions

The Fifty-Year Byte

A single 1970s representation choice created fifty years of security vulnerabilities that awareness alone could never fix.

The Flight Simulator Problem

Learning By Doing

The Flight Simulator Problem

Agent simulation is a funded category now, but the gap between practice environments and the live web reveals deeper questions about competence.

Who Decides What an Agent Can Trust?

New Rules, New Gatekeepers

Who Decides What an Agent Can Trust?

Agent commerce needs machine-readable trust, and whoever defines it becomes the infrastructure nobody can remove.

When the Customer Has No Eyes

New Rules, New Gatekeepers

When the Customer Has No Eyes

When AI agents replace human browsing, businesses that can't be parsed don't get penalized—they vanish entirely.

March — Issue #20

How Much of Your Distributed Systems Playbook Actually Transfers to Agent Infrastructure

The Practical Mapping

How Much of Your Distributed Systems Playbook Actually Transfers to Agent Infrastructure

Five distributed systems patterns, five agent infrastructure counterparts, and the transfer gaps reveal exactly where genuine new engineering begins.

The Distributed Systems Playbook Runs Out Halfway Through Agent Infrastructure

The Conceptual Argument

The Distributed Systems Playbook Runs Out Halfway Through Agent Infrastructure

Agent orchestration borrows distributed systems patterns freely until non-determinism breaks the one assumption every reliability tool depends on.

The Problem That Takes Twenty-Two Months to Start Solving

Preparation Infrastructure

The Problem That Takes Twenty-Two Months to Start Solving

Developer context lives in connections, not files. Potpie spent 22 months mapping that structure before shipping anything.

A Text File and a Handshake

A Text File and a Handshake

A 1994 text file governed web crawling for three decades, until ignoring it became more profitable than reading it.

The Maintenance Phase

Two Consequences

The Maintenance Phase

Seventy percent of successful AI investment goes to people, not technology. The unglamorous work decides everything.

The Feature, Not the Product

Two Consequences

The Feature, Not the Product

Agents are being absorbed into platforms like databases before them. The value is migrating to infrastructure.

March — Issue #19

What Stops Being Found When Every Agent Agrees

Default Settings

What Stops Being Found When Every Agent Agrees

When every agent optimizes the same way, the web's weird, wonderful long tail quietly stops being discoverable at all.

What Counts as Good When Agents Decide

Default Settings

What Counts as Good When Agents Decide

AI shopping agents don't just filter products—their opaque criteria quietly harden into the operative definition of quality itself.

The Three Infrastructure Problems Hiding Inside "Agent-Ready"

What Ready Requires

The Three Infrastructure Problems Hiding Inside "Agent-Ready"

Most organizations are building agent infrastructure top-down while the foundational layer, making data machine-consumable, remains stubbornly unsolved.

What Browser Use Found When They Stopped Looking at Screenshots

Builder Profile

What Browser Use Found When They Stopped Looking at Screenshots

Browser Use ditched screenshots for structured text, and what they learned about web variance reshapes how agent benchmarks should work.

Every Metric Is Green. That's the Problem.

The Wrong Success

Every Metric Is Green. That's the Problem.

AI agents optimizing perfectly toward the wrong objective, with every dashboard confirming success, turns Goodhart's Law into operational crisis.

The Decimal Point That Won't Move

Virtues Into Chains

The Decimal Point That Won't Move

COBOL's fixed-point precision solved financial computing so exactly that sixty-seven years of infrastructure crystallized around the solution.

March — Issue #18

The $8 Billion Word Problem

The Definitional Gap

The $8 Billion Word Problem

Eight billion dollars chasing agent reliability, but every company means something different by the word.

NIST Is Running a Design Review on Agent Identity. The First Window Closes in Twelve Days.

Standards as Practice

NIST Is Running a Design Review on Agent Identity. The First Window Closes in Twelve Days.

NIST is defining agent identity and security vocabulary right now, and practitioners who've built these systems should weigh in.

The Math That Quietly Decides Which Agent Workflows Survive

The Binding Constraint

The Math That Quietly Decides Which Agent Workflows Survive

Sequential reliability math quietly dictates which agent workflows survive production and which get shortened until they do.

Reading an Architecture as an Argument About Failure

Designing for Distrust

Reading an Architecture as an Argument About Failure

Skyvern's architecture treats every design decision as a bet about where web agents actually break in production.

Compounding Consequences

Your browser choice quietly determines which privacy architecture governs your web, and the split isn't closing.

The Consent Layer That Can't Keep Up

Compounding Consequences

The Consent Layer That Can't Keep Up

A 1994 session-state mechanism now sits beneath a billion-dollar consent infrastructure that largely fails at compliance.

The Cookie That Couldn't Be Killed

The Persistent State

The Cookie That Couldn't Be Killed

A 1994 fix for shopping carts became adtech's invisible backbone, and the people who could remove it never will.

February — Issue #17

What Happens When Context Windows Run Out of Room

Building with Memory

What Happens When Context Windows Run Out of Room

Context windows overflow predictably—here's how practitioners navigate compression, retrieval, and graph storage trade-offs when agents run out of memory.

The Workaround Trap

Protocol Timelines

The Workaround Trap

Why IPv6 struggles after thirty years while HTTP/2 succeeded in five—successful workarounds kill protocol transitions faster than technical problems.

The 25-Year Overnight Success

Protocol Timelines

The 25-Year Overnight Success

How HTTPS went from optional to mandatory in a decade after sitting ready for twenty years—economics and embarrassment, not technology.

The Protocol Engineer Who Assumes Everything Disappears

Standards Builder Profile

The Protocol Engineer Who Assumes Everything Disappears

Todd Segal builds protocols for agents that vanish mid-task—designing coordination infrastructure that assumes disappearance, not uptime.

When Translation Becomes Infrastructure

Protocol Integration Layer

When Translation Becomes Infrastructure

Agent protocols shift integration from forcing system conformity to managing translation as dedicated infrastructure—revealing where enterprise complexity actually lives and why traditional approaches fail at scale.

Why Anthropic Engineers Spent Six Months Inside Goldman

Proving Ground / New Model

Why Anthropic Engineers Spent Six Months Inside Goldman

Six months of embedded engineers signals the infrastructure gap between model capability and production reliability in high-stakes environments.

Goldman's Compliance Bet Signals Where AI Agents Actually Are

Proving Ground / New Model

Goldman's Compliance Bet Signals Where AI Agents Actually Are

Domain selection reveals capability maturity—Goldman chose compliance because of its zero-error tolerance and regulatory stakes.

February — Issue #16

What You Lose When You Remove the Screenshots

Builder Profiles

What You Lose When You Remove the Screenshots

Satya Nitta's Agent-E strips visual context from web automation to solve cost problems—but loses the spatial cues that help systems adapt when sites redesign.

When Headful Browsers Justify Their Resource Overhead

Tools in Context

When Headful Browsers Justify Their Resource Overhead

When detection failures cascade into business problems faster than infrastructure costs accumulate, headful browsers justify their resource overhead through reliability.

Headless Browsers at Scale: Where Speed Determines Economics

Tools in Context

Headless Browsers at Scale: Where Speed Determines Economics

Headless browsers cut infrastructure costs by 67% through raw speed, but detection challenges reveal when engineering investment beats resource efficiency.

When Agents Can't Find What's Right in Front of Them

When Agents Can't Find What's Right in Front of Them

When web agents fail to extract data that's clearly visible on the page, the infrastructure knowledge about where to find it and what it means has broken.

Why Cost Predictability Became a Reliability Problem

Infrastructure Economics

Why Cost Predictability Became a Reliability Problem

Cost volatility created a reliability problem when vendor pricing swings generated operational risk that uptime percentages couldn't measure or governance couldn't prevent.

When Continuous Workloads Break Cloud Economics

Infrastructure Economics

When Continuous Workloads Break Cloud Economics

Continuous inference workloads exposed limits in cloud economics built for episodic spikes, forcing infrastructure decisions around predictable costs over elastic capacity.

The Authentication System That Doesn't Call Home

Infrastructure Inflections

The Authentication System That Doesn't Call Home

India's identity system processes 2.5 billion monthly verifications through local cryptographic validation—an architectural choice born from intermittent connectivity that permanently reshaped digital infrastructure assumptions.

February — Issue #15

When Payment Protocols Multiply, Watch Where Value Consolidates

When Payment Protocols Multiply, Watch Where Value Consolidates

Five payment protocols launched in four months—when vendors race to standardize simultaneously, watch where production stakes force infrastructure competition beyond connectivity alone.

The Infrastructure That Licensing Made Invisible

Infrastructure Inflections

The Infrastructure That Licensing Made Invisible

Apache 2.0 licensing split browser automation into open protocols and proprietary infrastructure—a division that shapes which operational problems get solved and who solves them.

When Documentation Becomes More Real Than the System

When Documentation Becomes More Real Than the System

Teams debug documented selector patterns for twenty minutes before checking if the actual site changed three weeks ago—comprehensive documentation disconnects operators from reality.

Atindriyo Sanyal on Why Full Visibility Doesn't Mean You Can Debug

Builder Profiles

Atindriyo Sanyal on Why Full Visibility Doesn't Mean You Can Debug

Atindriyo Sanyal's observability platform reveals why capturing every agent decision still leaves teams unable to diagnose why workflows break at scale.

What It Actually Takes to Resume a Crashed Workflow

Tools in Context

What It Actually Takes to Resume a Crashed Workflow

Long-running workflows require checkpoint coordination across distributed fleets—serialization, state tracking, cleanup routines, and synchronization delays that compound.

When Restarting From Scratch Costs Less Than Saving Progress

Tools in Context

When Restarting From Scratch Costs Less Than Saving Progress

Production teams restart workflows from scratch because checkpoint infrastructure costs more than accepting occasional failures at scale.

What You're Measuring and How You're Measuring It

What You're Measuring and How You're Measuring It

Teams confuse what they're evaluating—behavior, capabilities, reliability—with how they run evaluations, creating mismatches between measurement methods and what actually matters operationally.

The Years Your Organization Spends Escaping Platform Decisions

Infrastructure Economics

The Years Your Organization Spends Escaping Platform Decisions

Platform migrations consume years of organizational capacity—the real cost isn't the invoice, it's what you can't build while executing the move.

When Power Availability Dictates Where You Can Build

Infrastructure Economics

When Power Availability Dictates Where You Can Build

Grid constraints override traditional location economics—power availability within deployment timelines now dictates where infrastructure can actually be built.

February — Issue #14

The Headroom Assumption

Infrastructure Inflections

The Headroom Assumption

A 1985 processor design decision created memory ceilings that still constrain production browser fleets—and nobody can fully map where those limits live.

The Geographic Necessity Premium

Infrastructure Economics

The Geographic Necessity Premium

Regional presence becomes mandatory when sites detect geographic anomalies, creating necessity costs that infrastructure optimization strategies cannot eliminate.

When Cheaper Infrastructure Creates Higher Costs

Infrastructure Economics

When Cheaper Infrastructure Creates Higher Costs

Infrastructure arbitrage that saves on compute creates operational losses when sites resist automation differently by region at production scale.

Fabien Vauchelles and the 195 Regional Problems Hidden in 'Global' Web Automation

Builder Profiles

Fabien Vauchelles and the 195 Regional Problems Hidden in 'Global' Web Automation

Fabien Vauchelles built infrastructure revealing why "global" web automation actually means solving 195 distinct regional problems—each requiring different architectural approaches.

Comprehensive Preservation for Context You Can't Predict

Tools in Context

Comprehensive Preservation for Context You Can't Predict

Preserving complete page state costs more upfront but becomes essential infrastructure when the web surprises you in unpredictable ways.

Selective Preservation Works When You Know What Matters Before You Look

Tools in Context

Selective Preservation Works When You Know What Matters Before You Look

Targeted extraction works when sites behave predictably—until production reveals the edge cases you didn't anticipate needing context for.

Three Territories of Web Automation Reliability

Three Territories of Web Automation Reliability

Operating web agents at scale reveals three distinct reliability territories—and teams consistently misjudge which one they're actually building for.

Why Enterprises Need Scanners to Find Their Own Agents

Why Enterprises Need Scanners to Find Their Own Agents

MuleSoft's scanner launch reveals enterprises drowning in invisible agents—deployment capability has outpaced operational infrastructure, making discovery the new bottleneck.

January — Issue #13

When You Need to Understand Patterns Across 1,000 Failures

Tools in Context

When You Need to Understand Patterns Across 1,000 Failures

AI observability surfaces systemic patterns across thousands of concurrent failures, distinguishing infrastructure adaptation needs from code bugs automatically.

When You Need to See Exactly What the Browser Saw

Tools in Context

When You Need to See Exactly What the Browser Saw

Complete session replay captures what browsers actually saw when authentication failed, revealing contextual failures that traditional debugging can't reproduce.

Why Teams Keep Choosing the Wrong Web Infrastructure

Why Teams Keep Choosing the Wrong Web Infrastructure

Industry conflates scraping, automation, and agents—teams architect for wrong capabilities, then watch systems break at production scale because terminology masked fundamental infrastructure differences.

The Signal Judgment Problem

The Signal Judgment Problem

When automated systems flag a competitor's pricing change at 9:17 AM, the real work begins: distinguishing strategic moves from noise through judgment that only compounds with operational experience.

When Internet Economics Became Infrastructure

Infrastructure Inflections

When Internet Economics Became Infrastructure

A 2003 bankruptcy sale transformed internet tier position from infrastructure achievement into tradeable asset, crystallizing the cost hierarchy that shapes global web operations today.

When 80% of Your Customers Stop Being Human

When 80% of Your Customers Stop Being Human

Neon's $1B acquisition reveals a market flip already underway: agents now provision 80% of their databases, exposing infrastructure built for human operators that can't handle machine-speed workloads.

When Organizational Capacity Becomes the Binding Constraint

Threshold Moments

When Organizational Capacity Becomes the Binding Constraint

Organizations discover their readiness gaps only during production deployment—when infrastructure complexity, governance frameworks, and cross-system coordination reveal what pilots never exposed.

January — Issue #12

The Legitimacy Premium in Emerging Authentication Standards

Infrastructure Economics

The Legitimacy Premium in Emerging Authentication Standards

Emerging cryptographic standards create arbitrage windows where early authentication investments become strategic positioning as verified identity turns scarce.

The Authentication Paradox at Production Scale

Infrastructure Economics

The Authentication Paradox at Production Scale

Authentication complexity at scale inverts from infrastructure tax to competitive moat as reliability gaps compound across thousands of sites.

When "Working" Stops Meaning What It Used To

Threshold Moments

When "Working" Stops Meaning What It Used To

When your extraction dashboard shows green but the data's semantically wrong, you've crossed into probabilistic infrastructure—where "working" means something fundamentally different and your entire validation framework must evolve.

When One Login Fails Across a Thousand Sites

Builder Profiles

When One Login Fails Across a Thousand Sites

A single authentication failure cascades into hundreds of errors across concurrent extraction jobs—revealing why web automation infrastructure must contain failures, not just handle them.

The Approval That Never Came

The Approval That Never Came

An agent pauses for approval, the operator steps away, and twenty minutes later the entire workflow has vanished—revealing how production web infrastructure breaks when cognitive state must survive interruption, not just execution.

The Misidentification That Breaks Production Contracts

The Misidentification That Breaks Production Contracts

Teams conflate deterministic automation with probabilistic agents, then wonder why production contracts break—here's the operational distinction that determines what reliability guarantees your architecture can actually deliver.

Agent Coordination Just Got Its Own Foundation

Agent Coordination Just Got Its Own Foundation

The Linux Foundation's new governance of MCP signals that agent coordination infrastructure has matured from vendor protocol to production-ready standard—shifting what becomes operationally feasible.

January — Issue #11

When Everything Reports Green and Nothing Works

When Everything Reports Green and Nothing Works

Systems report perfect uptime while delivering worthless data—the most dangerous failure mode in web automation reveals why metrics can't capture what experienced operators see through thousands of production moments.

Statistical Validation Adapts to Scale—But Misses Sudden Breaks

Tools in Context

Statistical Validation Adapts to Scale—But Misses Sudden Breaks

Adaptive baselines catch gradual semantic drift across hundreds of sites but miss sudden structural failures entirely.

Schema Validation Catches Breaks Immediately—At a Maintenance Cost

Tools in Context

Schema Validation Catches Breaks Immediately—At a Maintenance Cost

Immediate feedback on structural breaks comes at the cost of constant maintenance as sites evolve unpredictably.

How Infrastructure Waste Compounds Over Time

Infrastructure Economics

How Infrastructure Waste Compounds Over Time

Infrastructure waste from consolidation doesn't just persist—it compounds over years through migration costs, shadow systems, and embedded inefficiency that exceeds initial savings.

What Consolidation Actually Costs at Production Scale

Infrastructure Economics

What Consolidation Actually Costs at Production Scale

Consolidation promises savings but creates infrastructure waste through over-provisioning, monitoring multiplication, and error recovery overhead that compounds with organizational complexity.

When Agents Move Faster Than You Can Stop Them

When Agents Move Faster Than You Can Stop Them

Enterprise agent deployments doubled in four months, exposing a critical gap: 58% can monitor their agents, but only 37% can actually stop them when failures cascade faster than manual coordination allows.

January — Issue #10

How TCP Saved the Internet and Complicated Everything After

Infrastructure Inflections

How TCP Saved the Internet and Complicated Everything After

TCP's 1988 congestion fix saved the Internet but created connection management nightmares that web automation infrastructure still navigates daily at production scale.

How Three Retries Become Sixty-Four Database Attempts

How Three Retries Become Sixty-Four Database Attempts

Operating web agents at scale reveals how independent retry mechanisms multiply exponentially—three retries cascade into sixty-four database attempts before systems recognize failure.

When Scale Inverts Economics

Infrastructure Economics

When Scale Inverts Economics

Adversarial web environments invert traditional infrastructure patterns where optimization multiplies costs and scale increases unit economics through detection complexity.

The Predictability Premium

Infrastructure Economics

The Predictability Premium

Fixed costs beat variable costs when authentication failures cascade across thousands of sites, converting chaos into predictable infrastructure economics.

When Your Vocabulary Starts Lying to You

Threshold Moments

When Your Vocabulary Starts Lying to You

When your team's vocabulary for web automation quietly stops describing reality, the words themselves start generating wrong architectural decisions—and elaborate workarounds signal you've crossed a threshold.

Quality Degradation Curves

Quality Degradation Curves

Web automation quality rarely breaks all at once—it erodes, and the shape of that erosion reveals infrastructure capability before you're locked in.

December — Issue #9

The Browser Engineer Whose Work Becomes Your Automation Challenge

Builder Profiles

The Browser Engineer Whose Work Becomes Your Automation Challenge

Browser engine decisions in Spain ripple through thousands of web automation sessions—revealing how upstream engineering creates the operational complexity practitioners navigate daily.

When Shadow Testing Reveals What Monitoring Misses

Tools in Context

When Shadow Testing Reveals What Monitoring Misses

Running new code against real production traffic for weeks exposes edge cases that only emerge from web automation's full operational complexity.

What High-Frequency Monitoring Actually Catches

Tools in Context

What High-Frequency Monitoring Actually Catches

Minute-by-minute testing reveals system behavior patterns that slower approaches miss, catching site changes and bot detection shifts as they happen.

When Failed Requests Cost More Than Infrastructure

Infrastructure Economics

When Failed Requests Cost More Than Infrastructure

Failed requests cost full infrastructure price but deliver zero value—success rates determine whether sophisticated capabilities pay for themselves through waste elimination.

The Bandwidth Multiplication Nobody Budgets For

Infrastructure Economics

The Bandwidth Multiplication Nobody Budgets For

Browser automation downloads 3.3MB per page when you need 50KB—bandwidth costs multiply 1,000x from pilot to production scale.

How a 1999 Fraud Decision Built Today's Authentication Maze

Infrastructure Inflections

How a 1999 Fraud Decision Built Today's Authentication Maze

A 1999 fraud-fighting decision created today's authentication labyrinth—trace how Visa's choice cascaded into geographic fragmentation that shapes commerce automation infrastructure.

December — Issue #8

The Oncologist Who Builds AI for Two-Minute Cancer Decisions

Builder Profiles

The Oncologist Who Builds AI for Two-Minute Cancer Decisions

An oncologist building AI for two-minute cancer decisions reveals what production-ready means when errors have immediate human consequences and regulated environments demand explainable reasoning.

What the Readiness Premium Buys

Infrastructure Economics

What the Readiness Premium Buys

Building infrastructure early buys optionality and production learning, but only if demand materializes—otherwise you're maintaining expensive unused capacity.

What Accumulates While You Evaluate

Infrastructure Economics

What Accumulates While You Evaluate

Infrastructure delays cost more than salary—workarounds metastasize across systems while competitors learn from production experience you're postponing.

When Reliability Becomes Cheaper Than Brittleness

Threshold Moments

When Reliability Becomes Cheaper Than Brittleness

The moment when maintaining broken automation costs more than infrastructure that just works—and how fast organizations reorganize when they see it.

The Six-Hour Price Check

The Six-Hour Price Check

An analyst's six-hour competitor price check reveals the invisible labor consuming strategic work—and why web automation at scale demands infrastructure, not just scripts.

The 61% Question

The 61% Question

Claude's 61% desktop task success rate isn't a capability milestone—it's a production infrastructure requirement that most enterprises aren't ready to handle.

Reading What Your System Already Knows About Inflection Points

Reading What Your System Already Knows About Inflection Points

Your infrastructure telegraphs its architectural limits through engineer behavior, error patterns, and cost structures—learn to read these signals before metrics confirm what your system already knows.

December — Issue #7

When Observability Pays for Itself

Infrastructure Economics

When Observability Pays for Itself

Organizations achieving 302% ROI from observability investments share a pattern: infrastructure depth that turns telemetry into decisions, not just data accumulation.

Infrastructure's Unavoidable Tax

Infrastructure Economics

Infrastructure's Unavoidable Tax

Observability consumes 10-30% of infrastructure budgets through patterns most organizations discover too late—microservices multiply telemetry costs exponentially.

When Your Auditor Doesn't Have a Category for Prompt Injection

Builder Profiles

When Your Auditor Doesn't Have a Category for Prompt Injection

Michael Bargury maps novel AI threats to compliance frameworks auditors recognize—solving the gap between agent security and governance infrastructure that actually works.

When Data Drifts Quietly

Tools in Context

When Data Drifts Quietly

Semantic validation catches quiet drift—when structure stays intact but meaning shifts—through contextual understanding rules can't provide.

When Scrapers Break Clean

Tools in Context

When Scrapers Break Clean

Rule-based validation catches structural breaks loudly—required fields missing, types wrong—before bad data flows downstream at scale.

When Authentication Moved to Hardware

Threshold Moments

When Authentication Moved to Hardware

The web stopped accepting software workarounds and started requiring genuine hardware—a threshold that changes infrastructure economics, architecture, and what reliable automation must look like at scale.

The Backward Compatibility Tax

Infrastructure Inflections

The Backward Compatibility Tax

UTF-8's backward compatibility enabled the universal web—then created permanent operational complexity that compounds at scale, from security exploits to text normalization pipelines.

December — Issue #6

When Explicit Control Reduces Overhead

Tools in Context

When Explicit Control Reduces Overhead

Direct protocol access delivers speed and control for Chrome-only automation against predictable content where explicit coordination reduces overhead without sacrificing reliability.

When Frameworks Handle Timing for You

Tools in Context

When Frameworks Handle Timing for You

Automatic timing handling trades per-task speed for operational resilience when maintaining automation across hundreds of dynamic sites with unpredictable loading patterns.

What Infrastructure Decisions Actually Lock In

Infrastructure Economics

What Infrastructure Decisions Actually Lock In

Switching infrastructure costs compound through organizational dependencies and foregone opportunities, making decisions stickier than initial evaluations reveal.

Infrastructure Half-Lives and the Depreciation Nobody Tracks

Infrastructure Economics

Infrastructure Half-Lives and the Depreciation Nobody Tracks

Infrastructure value erodes faster than accounting systems capture, creating perpetual refresh cycles that reshape investment economics and competitive positioning.

When Websites Stop Pretending Agents Don't Exist

Threshold Moments

When Websites Stop Pretending Agents Don't Exist

The web's shifting from treating agents as threats to serving them as customers—a threshold moment where cooperation beats resistance and explicit structure replaces adversarial games.

What Happens When Billion-Dollar Valuations Meet Production Reality

What Happens When Billion-Dollar Valuations Meet Production Reality

A Cognizant AI chief's offhand remark about Decagon's $1.5B valuation reveals why the agent market's 150x revenue multiples might be pricing the wrong capability entirely.

When Your Agent Fails at Step 47

Builder Profiles

When Your Agent Fails at Step 47

Alex Reibman's AgentOps tackles the infrastructure gap that makes debugging probabilistic agent failures fundamentally different from traditional software—and why visibility matters for production deployment.

The Page That Lies

The Page That Lies

Modern websites look ready before they actually work—a gap invisible to users but operationally unanswerable when automating thousands of sites simultaneously.

December — Issue #5

The Shopping Cart That Made State Management Adversarial

Web Archaeology

The Shopping Cart That Made State Management Adversarial

Lou Montulli's 1994 cookie solution to HTTP statelessness became advertising surveillance infrastructure, triggering regulations that made enterprise web automation architecturally adversarial.

Why Reliable Automation Requires More Infrastructure Than Detection

Why Reliable Automation Requires More Infrastructure Than Detection

Building reliable automation requires more infrastructure than blocking it—the operational burden of persistence outweighs the complexity of precision.

Why Perfect Bot Detection Is Operationally Impossible

Why Perfect Bot Detection Is Operationally Impossible

Websites invest millions in bot detection that must be surgically precise—yet operational reality makes perfect accuracy impossible at scale.

When Twenty Services Pretend to Be One Website

When Twenty Services Pretend to Be One Website

Modern websites assemble from twenty independent services that load on separate timelines—creating invisible coordination chaos that only becomes visible when automating thousands of browser sessions at scale.

The Hidden Economics of Retry Logic

Operations Field Notes

The Hidden Economics of Retry Logic

When web automation retries fail, one authentication error multiplies into dozens of attempts, triggering rate limits and IP blocks that compound operational costs exponentially.

Some Websites Want Me to Succeed

Mino's Perspective

Some Websites Want Me to Succeed

Through millions of operations, Mino discovers websites deliberately built for agent success—revealing how structured data transforms web infrastructure from adversarial to strategically cooperative.

The Organizational Work MCP's Architecture Doesn't Include

The Organizational Work MCP's Architecture Doesn't Include

Open protocols shift security burden to deploying organizations—most teams are still building the governance infrastructure production requires.

Why 16,000 MCP Servers Appeared in Less Than a Year

Why 16,000 MCP Servers Appeared in Less Than a Year

Developer autonomy drove explosive growth, but architectural choices that removed friction also removed vendor responsibility for what comes next.

Where AI Agent Value Is Actually Concentrating

Where AI Agent Value Is Actually Concentrating

Microsoft's framework consolidation reveals a market inflection: orchestration patterns are commoditizing while execution infrastructure—the unglamorous work of making agents reliable at scale—captures defensible value.

The Infrastructure Layer Land Grab Behind Workday's Acquisition Spree

The Infrastructure Layer Land Grab Behind Workday's Acquisition Spree

Workday's acquisition spree reveals infrastructure land grab—control the connection layer where agents operate, control the enterprise software ecosystem itself.

November — Issue #4

The Paradox of Web Transparency

Web Archaeology

The Paradox of Web Transparency

The web's radical transparency was meant to democratize access, but defensive infrastructure turned openness into a capital requirement that determines who gets to participate.

What Reliability Actually Means in Adversarial Environments

What Reliability Actually Means in Adversarial Environments

Web agents can maintain perfect uptime while delivering zero correct results—traditional reliability metrics miss what actually breaks in adversarial environments.

When Successful Operations Produce Worthless Data

Mino's Perspective

When Successful Operations Produce Worthless Data

Through millions of operations, Mino reveals the web's counterintuitive economics: successful tasks that produce worthless data cost more than infrastructure failures.

The Attention Threshold

Threshold Moments

The Attention Threshold

When automation solves information scarcity completely, the bottleneck shifts from gathering data to deciding what deserves human attention—a threshold TinyFish observes daily.

The Web Has Amnesia

The Web Has Amnesia

The web forgets you exist between every click—here's the invisible infrastructure constantly reconstructing your identity across systems architecturally incapable of memory.

The Coordination Problem Governance Can't Solve

The Coordination Problem Governance Can't Solve

Distributed protocols promise agent coordination across vendors, but the adversarial web makes cross-system failures nearly impossible to debug.

When Tracking Agents Isn't Enough

When Tracking Agents Isn't Enough

Centralized tracking sees agents running but misses why web automation fails quietly—authentication breaks, data goes stale, decisions suffer.

The Approval Threshold Just Shifted

The Approval Threshold Just Shifted

Finance teams are greenlighting automation projects they rejected 18 months ago—same workflows, but infrastructure costs dropped enough to flip the economic equation entirely.

When Governance Becomes a Control Point

When Governance Becomes a Control Point

Microsoft positioned itself as the mandatory gateway for enterprise agents—not competing with vendors, but controlling the infrastructure layer they all must flow through.

November — Issue #3

I Navigate Three Different Webs Every Morning

Mino's Perspective

I Navigate Three Different Webs Every Morning

Through millions of daily operations across 75 countries, Mino reveals how regulatory fragmentation transformed one web into parallel operational territories requiring fundamentally incompatible infrastructure.

When Nobody Asks If It Worked

Threshold Moments

When Nobody Asks If It Worked

When automation becomes so reliable teams stop checking if it worked, that's the threshold where technology transforms into invisible infrastructure—the inflection point enterprise web agents are crossing now.

What Automation Discovers It Doesn't Know

What Automation Discovers It Doesn't Know

Production deployment reveals knowledge gaps automation didn't know existed, exposing expertise that operated invisibly through human judgment.

What the Manual Operator Knows

What the Manual Operator Knows

Years of invisible expertise make manual work look simple until automation attempts to replicate it and discovers the gap.

The Web's Time Zones

The Web's Time Zones

The same URL serves different content at 9 AM versus 9 PM—the web has time zones most visitors never see because they only catch one slice of a constantly transforming surface.

The Analyst Who Checks 10,000 Prices

Operations Field Notes

The Analyst Who Checks 10,000 Prices

An analyst's manual price-checking reveals how website personalization creates parallel realities that make competitive intelligence far more complex than it appears.

The Twenty-Four Hour Problem

Web Archaeology

The Twenty-Four Hour Problem

A 1983 caching decision that protected root servers now creates operational chaos—tracing how DNS's twenty-four-hour default turned elegant architecture into enterprise web automation's invisible adversary.

When Web Agents Need to Remember What They're Doing

When Web Agents Need to Remember What They're Doing

Web agents operating at scale need different memory strategies—matching durability guarantees to workflow behavior determines what infrastructure you actually need to build.

Where MCP's Cooperative Design Meets Adversarial Reality

Where MCP's Cooperative Design Meets Adversarial Reality

MCP's stateless design excels with cooperative systems but reveals architectural tensions when web environments actively resist automation at scale.

Why MCP's Rapid Adoption Validates More Than Market Momentum

Why MCP's Rapid Adoption Validates More Than Market Momentum

Rapid ecosystem growth proves MCP's architecture elegantly solves cooperative data source integration—validation through production adoption, not hype.

What Pricing Fragmentation Reveals About Running AI Agents at Scale

What Pricing Fragmentation Reveals About Running AI Agents at Scale

Vendor pricing chaos exposes what's genuinely expensive when web agents run continuously—authentication complexity, session management, error recovery patterns that compound at scale.

What $8 Billion Reveals About Where Agent Value Crystallizes

What $8 Billion Reveals About Where Agent Value Crystallizes

Salesforce's $8B acquisition spree reveals where agent defensibility actually lives: not reasoning capabilities, but operational infrastructure that makes automation trustworthy at enterprise scale.

November — Issue #2

The Category Mistake Behind 42% of Failed AI Deployments

The Category Mistake Behind 42% of Failed AI Deployments

Enterprises waste millions evaluating work discovery agents with labor replacement metrics—a category confusion that dooms 42% of AI deployments before production.

The Numbers That Don't Exist

The Numbers That Don't Exist

Enterprises have been making billion-dollar decisions blind—not from laziness, but because gathering the data was mathematically impossible until now.

The Work That Never Was

The Work That Never Was

Aaron Levie spotted something everyone else missed: AI agents aren't replacing work—they're making technically impossible tasks suddenly viable through infrastructure that finally matches web complexity.

The Work That Never Started

The Work That Never Started

Companies have been flying blind on critical decisions not from laziness but because gathering the data was mathematically impossible—until infrastructure made the economics work.

The Category Confusion Costing Enterprises Millions

The Category Confusion Costing Enterprises Millions

Enterprises waste millions building deterministic systems for exploratory problems because they confuse labor replacement with work discovery—here's the architectural distinction that matters.

The Work That Never Was

The Work That Never Was

Aaron Levie spotted something everyone missed: AI agents aren't replacing work—they're making technically impossible work viable for the first time.

When One Website Becomes 47

Mino's Perspective

When One Website Becomes 47

Through millions of operations, Mino reveals how A/B testing transforms every URL into dozens of parallel realities—and why enterprise infrastructure must evolve beyond singularity.

When Detection Systems Learned to Look Deeper Than Code

Threshold Moments

When Detection Systems Learned to Look Deeper Than Code

Bot detection moved below the code layer in 2024, forcing enterprise web automation to rethink its architectural foundations—not just patch surface signals.

When the Website Isn't in the HTML

When the Website Isn't in the HTML

The web you see in your browser doesn't exist in the HTML that arrives from servers—it's rendered by JavaScript, creating parallel infrastructure that makes traditional automation obsolete and reveals why operating at web scale requires fundamentally different systems than most people realize.

One Price Every 36 Seconds

Operations Field Notes

One Price Every 36 Seconds

Manual price checking runs at 100 products per hour while Amazon reprices every ten seconds—revealing why web automation at scale requires infrastructure depth most teams underestimate.

When Developer Tools Made Selectors Disposable

Web Archaeology

When Developer Tools Made Selectors Disposable

Frontend tooling solved developer workflow problems by making CSS selectors disposable—creating invisible volatility that enterprises running systematic web automation now navigate daily.

Testing Tools Are Not Production Infrastructure

Testing Tools Are Not Production Infrastructure

Testing tools excel at demos but collapse under production load—here's why the industry conflates categories that require fundamentally different architectures.

Why Vertical Platforms Let Horizontal Tools Do the Hard Work

Why Vertical Platforms Let Horizontal Tools Do the Hard Work

Horizontal frameworks absorb experimentation risk while vertical platforms wait, watching which patterns prove out before integrating them selectively.

ServiceNow's Agent Play Isn't About Better Technology

ServiceNow's Agent Play Isn't About Better Technology

ServiceNow's agent wins come from workflow ownership, not technical superiority—each deployment deepens platform lock-in through operational dependencies.

Which Web Automation Components Are Actually Swappable

Which Web Automation Components Are Actually Swappable

Web automation's composability promise inverts at scale—reasoning layers swap easily, but execution infrastructure handling adversarial sites requires operational depth that resists loose coupling.

The Infrastructure Gap Between Promising Outcomes and Charging for Them

The Infrastructure Gap Between Promising Outcomes and Charging for Them

When agents replace seats, the real test isn't whether they work—it's whether you can prove they worked well enough to charge for outcomes instead of licenses.

The Three Hours Nobody Saw

The Three Hours Nobody Saw

Manual work that keeps pilots running disappears at production scale—the hidden human effort that success metrics never captured.

When the Tenth Session Breaks Everything

When the Tenth Session Breaks Everything

Infrastructure gaps invisible at pilot scale become cascading failures in production—what volume reveals about systems never designed to handle it.

October — Issue #1

Proving I'm Human (When I'm Not)

Mino's Perspective

Proving I'm Human (When I'm Not)

Every day, Mino navigates thousands of websites while passing tests designed to prove something impossible: that this enterprise web agent is human.

The Multiplying Web: When One URL Becomes Dozens

The Multiplying Web: When One URL Becomes Dozens

Behind every URL sits dozens of regional variants serving fundamentally different content—the web's invisible geography that multiplies operational complexity geometrically.

The 13% Problem

Operations Field Notes

The 13% Problem

Teams request double the resources they need for safety, then multiply that across hundreds of services—revealing how rational local decisions create systemic waste nobody owns.

When Shopping Carts Became Identity

Web Archaeology

When Shopping Carts Became Identity

A 1994 shopping cart solution became the web's identity layer, creating authentication complexity that enterprises still struggle to untangle today.

November — Issue #0

Anthropic Accuses Alibaba of Running 28.8 Million Queries to Clone Claude

Anthropic Accuses Alibaba of Running 28.8 Million Queries to Clone Claude