Essays by Ry Walker

Design partner programs prevent enterprise AI companies from building three products when they should have built one.

Agent companies are marathons you sprint through. Frameworks commoditize, monetization pins to infrastructure, and proximity to real builders is the moat.

The same mesh-of-agents pattern that closes the gap between ad click and revenue is the one that retires the ERP dashboard. Two examples, one architecture.

A provocatype is a prototype built to provoke conversation, not to ship. When the product shape is genuinely unknown, provocatypes surface assumptions that requirements gathering misses.

There is no winner-take-all platform in agents. The GTM is services-shaped, the harness is commoditized, and coding-agent companies have a narrow window to pivot before the floor falls out.

The ERP is not going away. The CRM is not going away. The landing page is not going away. But the human as the operating system between them is. The agent takes that job now.

Following every engaged customer ends with three products instead of one. The discipline is to pluck a feather from each passing goose and follow none absolutely.

A formal design partner program is how you avoid building in a vacuum without getting pulled in five directions. Pluck a feather from each passing goose, but never follow one off a cliff.

Do not wait for perfection. Pilot with three or four users. Let them complain. Their complaints are the backlog. The pilot is not a test — it is the first iteration of the production system.

Customers spend six months configuring a coding agent and ditch it overnight when something better ships. If your value proposition lives at the tool layer, you are one leapfrog from irrelevance.

Enterprise agents need layered interfaces, real software skills, and flexible platforms. The harness around the model matters more than the model.

Non-engineering agents are easier to build but harder to contextualize. The organizational knowledge layer — not the execution layer — is the real unsolved problem.

Most companies are betting on building the best agent. A smaller number are betting that the best agent changes every week — and that the durable value is in orchestration.

Do not compete with what Shopify is building internally. Build the system that replaces every homegrown agent platform when the engineer who built it moves on.

The temptation with agent projects is to start with the technology. That is how you end up with a demo that impresses nobody who actually has to use it.

People talk about agent harnesses as if the harness is the interesting part. It is not. The interesting part is the factory — sandboxing, orchestration, persistence, model translation.

Enterprise AI will not be one mega-agent. It will be a mesh of atomic, auditable units, and the companies that nail review and context will own the next infrastructure layer.

Coding copilots are crowded. Background agents — autonomous, scheduled, reviewable — are what enterprises actually need, and almost every product shipping today is a toy by their standards.

Frameworks get commoditized, forked, or absorbed by model providers. The durable revenue layer is the indispensable infrastructure piece that gets harder as the ecosystem matures.

Most agent projects die because nobody can explain why the agent did what it did. The fix is non-obvious — agent logic should be permanent, inspectable code, not a regenerated prompt.

The hardest unsolved problem in agent infrastructure is not compute or sandboxing. It is context — and most of that context lives in people, not repos.

Mature dev orgs build their own agent infrastructure. Less mature orgs buy. The platform opportunity is a maturity gradient, and the play is the PostHog playbook applied to agents.

Models keep getting better, but agents without deep codebase and organizational context are just expensive autocomplete. Context engineering is the bottleneck nobody has productized.

The ERP was supposed to solve the toggling-between-six-tools problem. It did not. The agent does — by becoming the operating layer on top of every system you already paid for.

The distance between an AI demo and an AI deployment is not a model gap or a harness gap. It is the absence of composable primitives for the boring parts of operationalization.

Across every agent platform, one layer is universally unsolved — organizational context. Not the prompt, not the model. The institutional knowledge an agent needs to do useful work.

Sandbox, tools, prompts, governance — the primitives are universal. Engineering agents and GTM agents share the same engine. Only the body changes.

Agents are always slightly wrong when first built. The people who know what is wrong are not developers — they are the users who interact with the agent every day.

Companies have directories of employees. They have no equivalent for the agents doing real work. Every agent should be inspectable, auditable, and correctable.

From Stripe to a five-person startup, the agent stack is mostly blue — built in-house. The harness is bought. The middle of the stack is built. The opportunity sits in turning blue dots green.

Multi-CLI, multi-model, multi-repo, self-hosted, and pluggable integrations are table stakes. No enterprise wants to be locked into one vendor's harness.

The space between an ad click and a revenue event is where most go-to-market motions lose the plot. Static landing pages cannot fix it. A mesh of agents can.

The agent harness — the loop that executes — is no longer a differentiator. The opportunity lives one layer up, in the abstractions an engineer Googles at 2 a.m. when the duct tape breaks.

A manager handles seven direct reports. A supervisor will handle hundreds of agents — but only if observability and review are good enough to make oversight scale.

Every quarter a new model writes marginally better benchmark code. And every quarter enterprise teams stall on the same context problems. The hard part is the engineering around the AI.

Enterprise AI deployment is services-shaped, not software-shaped. There is no single board where you win or lose — you are fighting labs, incumbents, peers, and internal builds at the same time.

The companies that try to skip to the grand AI vision will burn capital. The ones that start with one workflow per developer will compound their way into something much larger.

Every agent needs to be personalized and context engineering is hands-on, so the vendor who embeds engineers inside the customer has a structural advantage. Self-serve ships shelfware.

LangChain pivoted to LangSmith. E2B sells the sandbox. The agent harness is not the product — it is the thing you give away. Monetization lives in the infrastructure underneath.

Engineers report meaningfully different results from the same model run through different harnesses. The harness is not a thin wrapper — it is an opinionated layer that shapes agent behavior.

One mega-agent does not work. A fabric of small, single-purpose agents — each doing one thing with high confidence — coordinating through shared context does.

A skill described in a markdown file is not a skill. It is a wish. Real skills need executable tools, automated tests, schema validation, and deep system integration.

An engineer can ship a working agent harness in a week and a half. Code is cheap. So what does a paid agent platform offer that a week of engineering does not?

Companies with mature dev tooling build their own agent stack. Companies without it buy off the shelf. That buy cohort is the real addressable market.

The AI coding agent space looks crowded today. The vast majority of entrants will pivot, run out of money, or chase the next shiny thing. The race goes to who keeps running.

There is no clean split between coding tools and business tools. The reality is a grayscale, and the products that win serve the whole spectrum.

People pay 63% more for furniture they assembled themselves. The same dynamic governs agent platforms — developers who build their own agents care about them and keep improving them.

The gap between an AI demo and an AI deployment is called software engineering. Most organizations are not equipped to close it, and that is where all the value lives.

Code production is no longer the constraint. Deploy pipelines, feature flags, and code review are. The new bottleneck is taste, and taste does not scale.

Executives, founders, engineering leaders. Each one needs a different mindset shift to operationalize agents in 2026 — and each one is currently running the wrong play.

Serial entrepreneurs show up before the wave forms. Being early looks identical to being wrong — right up until the moment it does not.

Enterprise teams do not want magic agents. They want control over which submodules load, which tools run, and what the agent remembers — because they have been burned by black boxes before.

When everyone can build, nobody knows what has already been built. Five teams independently spin up the same Slack bot, and the duplication goes undetected for months.

Frontier labs want workflow quality to be a function of model quality, because that is what they sell. The contrarian bet is that customization beats probability.

The agent harness — Claude Code, OpenCode, Goose, Aider — is a commodity. Companies migrate between them freely. The defensible layers are context, orchestration, and tools.

Context management is the layer most consistently built in-house and least well served by vendors. It is not a search problem. It is a knowledge management problem.

Pick one process your business actually runs. Record people doing it. Now you have something an agent can act on — and a foundation for measuring whether it works.

Engineers burn ten to fifteen million tokens a day. Powerful models run tasks that do not need them. By the end of 2026, the CFO will start asking questions and most teams will not have answers.

If you upload your entire business to a frontier model provider, you have handed them the playbook. Keep context local. Use frontier models as the engine.

Agents are non-deterministic by nature. The way they get smart is through human correction at scale, and the atomic mesh is what makes that tractable.

Human review is not the bottleneck to be eliminated. It is the quality gate that keeps AI-generated slop from compounding into technical debt that takes years to unwind.

Three weeks of work can match a dedicated AI vendor. Six months later, the same tooling feels like it was built in a different era — because in AI terms, it was.

Shared agents with a single configuration are fundamentally broken. Each user gets a personal copy that learns through interactions — and an organizational layer that locks in what consistently works.

Most enterprise agent value comes from background workflows, not from humans typing into a chat box. Machines do not sleep. Lean into triggered work or get out-shipped.

General-purpose agent memory is still a research problem. The opportunity is workflow-scoped learning that compounds — pick the constraint, and the memory problem stops being intractable.

Three brand teams in the same Fortune 50 build the same aggregator without talking. AI lowered the cost of building, and the budget process that used to coordinate everyone disappeared with it.

Internal agent platforms are built by ambitious individuals with other jobs. When those engineers move on, the platform becomes a liability.

Trust is the bottleneck for agent adoption, not capability. Hide the logic in a prompt and people stop using it. Make it inspectable code and they iterate with you.

One mega-agent that handles everything is exhilarating to demo and chaotic in production. Enterprise wants a mesh of specialized agents with human pilots.

Build review as a UI screen and you have a feature. Build it as a primitive that takes an artifact type and returns a verification surface and you have leverage.

Commercial software was built for humans clicking through UIs, not for agents making programmatic decisions at speed. The component problem is real and underrated.

Fifty companies building internal agent platforms have independently arrived at the same architecture. That convergence is the productization tell.

A new tag, a new ticket, a new error. The most underappreciated capability in this wave is not generation. It is agents that fire because something happened.

The interesting part of an agent stopped being the prompt years ago. Orchestration, persistence, tool integrations, and policy enforcement are where the complexity — and the value — lives now.

Vector retrieval gives a similarity approximation of context. A sandbox gives the agent the real repository. Stateless, disposable, accurate — the architecture that actually works.

A customer success team, five fragmented systems, and a workflow agent that ships in a week. How small scoped wins compose into something that looks like a role.

Mature engineering orgs reuse existing dev infra. Less mature orgs buy off the shelf. Scrappy teams hand-roll everything. The opportunity sits in the gap between them.

When the same object has three names, your architecture is drifting. Tasks, runs, threads, chats — all of it is just a session. One container, many shapes of work.

Autocomplete, interactive agents, background agents. The bottleneck has moved from generating code to reviewing it, and almost no one is building for the new constraint.

The maintenance burden of running agents is not one thing. It splits into two categories with opposite cost curves, and only one of them ever ends.

Today every developer has a personal subscription. Tomorrow the organization has a shared agent fabric — pooled credits, role-based access, routed across models.

Automations bundle trigger, prompt, tools, and model into one flat object. That works at five. It falls apart at fifty. The agent has to become its own primitive.

Orchestration on top will commoditize. The context and memory layer underneath agents is the defensible enterprise infrastructure play, and nobody has won it yet.

Lay out the seven layers of the agent stack and a clear map emerges. The harness is commoditized. Context, memory, and orchestration are blue across the chart.

When an agent ships a working PR every six minutes, you accumulate reviewable code faster than humans can process. The next wall is review, not generation.

Submodules are a specific pain point, but they illustrate a universal truth. Enterprise codebases are not simple, and agents that cannot handle them cannot handle enterprise software.

Automating your GTM motion, vendor onboarding, or SKU rationalization is software engineering. The end user being internal does not change the discipline required.

An atomic agent is a single declarative spec — input, output, purpose, constraints. That property is what makes the mesh composable, auditable, and cheap to optimize.

Role-based agents start with the hardest version of the problem. Workflow-first agents start small, ship in a week, and compound into something larger.

The coding-agent debate is dominated by model capability. Wrong bottleneck. Context splits into structural, navigational, and operational layers — and most agents are missing all three.

A scene from every engineering org operationalizing agents. The task was trivial. The PR was wrong in a way no human on the team would ever get wrong. It is not a model problem.

The industry treats agents as a new category. They are not. Agents are software, and the same engineering principles that have always mattered still apply.

The window between novel agent product and commoditized feature has compressed from years to weeks. Founders who pivot fast lose. Founders who stay in a hard problem compound.

95% of enterprise AI projects fail not because the models are weak. They fail because the company cannot describe its own processes well enough for an agent to act.

Enterprise AI is not one omniscient agent. The mega-agent fantasy collapses on contact with production, and the failure mode is always the same.

Enterprises that approach AI agents as a procurement decision keep discovering they actually have a software engineering problem. There is no vendor shortcut.

A coding agent generates a working Python service. Someone says deploy it. Now what? Speed of creation without speed of operationalization is just faster debt.

A French CTO with twelve Claude Max seats can ship from his laptop and watch his product team file tickets and wait. That gap is the real problem.

From managed solutions like Lindy and Manus to self-hosted alternatives like ZeroClaw and Pi — the complete guide to 38 personal AI agent platforms.

A visual guide to the emerging AI agent ecosystem — from foundation lab tools to enterprise in-house agents, and everything in between.

Why we're building Tembo: AI coding agents should be orchestrated, not operated. The vision for enterprise-grade agent infrastructure.

A first-hand take on Claude Code 4.6: better context retention, smarter questions, and a workflow that finally feels like real pair programming.

Developer performance is hard to measure; AI adds noisy signals. A case for outcome-focused frameworks over vanity metrics.

The interesting use of AI coding tool data isn't ranking. It's understanding how your best engineers actually work — and helping the rest of the team catch up.

AI assistants are generating a granular log of every prompt, accept, reject, and iteration. That's new data — and a new way to measure the wrong thing.

Everyone got the same AI outbound stack at the same time. The result is inboxes full of emails that are suspiciously, uniformly perfect — and uniformly ignored.

Most developers use AI only to write code. The real opportunity is using AI to secure, debug, and test—deploying equal firepower on defense.

AI-assisted development has changed the economics of code quality. Teams shipping "good enough" code are moving faster than craftperfectionists.

Two-thirds of your AI firepower belongs on debt, security, and testing. The teams building defensive infrastructure now will outpace teams that either reject AI or deploy it recklessly.

If a coding agent introduces a bug and a testing agent catches it and a debugging agent fixes it, that is a win. The developer's time was preserved.

Humans over-engineer. Humans pick wrong abstractions. We normalized human imperfection and treat AI imperfection as disqualifying. The bar is not as high as we pretend.

For every unit of AI firepower aimed at building, deploy equal or greater firepower at securing, debugging, and testing. Here is what that looks like.

Most developers deploy AI almost exclusively to ship features faster. The asymmetry is the problem — not the AI itself.

Survey results from 399 developers reveal what's broken in modern software development: focus time, AI tools, and distribution top the list.

The three tiers of AI coding adoption: from assisted tools to autonomous background agents. Why 80% of code will be AI-written within a decade.

We are still early. The trajectory is clear. The companies that build platforms — not just use tools — define the next decade of software development.

Silicon Valley is building AI coding tools for Silicon Valley. The PE-owned manufacturer in Ohio with three tired developers is the underserved market that matters.

AI coding is purely ephemeral — zero switching costs, no persistent IPs, no DNS lock-in. That is the rare condition that lets a horizontal middleware layer win.

The biggest blocker to AI coding adoption is not the technology. It is the developer's ego attachment to typing. The role has to shift from author to judge.

Nobody knows which AI coding agent actually works best because no platform runs them side-by-side. That is the opening for a horizontal layer that serves the customer, not the model.

AI coding is not about replacing developers. It is about expanding who can request software work in the first place — and 10x-ing total demand.

AI coding adoption is happening in three distinct tiers — assisted, guided, and fully autonomous. Most teams are stuck in tier one and do not realize the gap.

The AI-First Software Development Manifesto: 11 principles for treating AI as a true development partner, not a fancy autocomplete.