<![CDATA[Forward Deployed]]>https://www.forwarddeployed.comhttps://substackcdn.com/image/fetch/$s_!ZH1m!,w_256,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F085ef4dc-b68f-4f21-9320-7cef3fb6e07e_1024x1024.pngForward Deployedhttps://www.forwarddeployed.comSubstackTue, 11 Aug 2026 21:29:50 GMT<![CDATA[Forward Deployed, Episode 9: Brave New Work for Agents]]>https://www.forwarddeployed.com/p/forward-deployed-episode-9-bravehttps://www.forwarddeployed.com/p/forward-deployed-episode-9-braveMon, 03 Aug 2026 12:19:15 GMTAaron Dignan joins me to talk about a pattern he recognized while building AI workflows at Plumb: “I’ve just created a newsroom.” Once agents have roles, decision rights, tools, inputs, and handoffs, you are not just designing software. You are designing an organization.

Aaron has spent two decades helping organizations change without calcifying. He founded The Ready, wrote Brave New Work, built Plumb, and now leads AI and digital product work at Rocket Money. That gives him a rare view across human organization design, agent workflows, and the hybrid systems now taking shape inside operating companies.

We start with the role work: purpose, responsibilities, decision rights, tools, access, and boundaries. Many of the patterns that make human teams legible still matter when the intelligence is in software. But the economics change. Production capacity no longer rises linearly with headcount, which makes coordination, context, and deciding what matters even more important.

From there we get into Time-Oriented Software Development, the idea that “everything runs on exhaust,” and the human sense-making moments that should remain around increasingly automated work. Aaron describes Anton, the voice agent he uses for roughly an hour a day, and we compare conversational interfaces with artifacts, checklists, and durable feedback loops.

The last part of the conversation turns to persuasion and ground truth, autocracy and consensus, and what happens when leaders can expose their preferences and prior decisions to a system that is not intimidated by them. The most interesting possibility is not AI replacing human intelligence. It is organization design with two different kinds of intelligence available at once.

Key Topics Covered

  • Roles and decision rights: Why purpose, responsibilities, tools, access, and boundaries still matter when the role is occupied by an agent.

  • Multi-agent systems as organizations: What Aaron learned when a workflow began to look less like software and more like a newsroom.

  • Specialization, hierarchy, and containment: Which durable organization patterns carry into systems made of software actors.

  • Two organization-design problems: Organizing agent systems and organizing the humans responsible for building and governing them.

  • Production and coordination: Why a discontinuity in production capacity makes shared context and deciding what matters more important.

  • Time-oriented development: Conceptualization, realization, and the human judgment point where the two meet.

  • Work that runs on exhaust: How automation can assemble context around the moments where a person needs to make sense of something.

  • Voice as an interface: How Aaron uses a voice agent called Anton to think, reflect, and create durable working material.

  • Artifacts and feedback loops: Why chat alone is a poor container for sustained collaborative work with agents.

  • Persuasion and ground truth: Where leadership judgment belongs and where data should be able to push back.

  • Applied preference: How prior decisions reveal what a leader actually values better than abstract instructions do.

  • Two kinds of intelligence: What becomes possible when organizations can draw on both embodied human judgment and consistent machine intelligence.

Timestamps

  • 00:10 - Introducing Aaron Dignan and organizing agents

  • 01:15 - Aaron’s path through organization design, Plumb, and Rocket Money

  • 02:32 - Why organizations calcify around budgets, plans, and their operating systems

  • 04:36 - Building workflows and realizing, “I’ve just created a newsroom”

  • 05:45 - Role work: purpose, responsibilities, and decision rights

  • 07:49 - Specialization, hierarchy, containment, and intelligence in silicon

  • 10:59 - Organizing agent systems and organizing the humans who build them

  • 12:44 - Production capacity expands; coordination and context become the bottleneck

  • 18:48 - Organization patterns as tradeoffs rather than universal answers

  • 20:41 - Time-Oriented Software Development and the OK Point

  • 22:08 - “Everything runs on exhaust” and designing human sense-making moments

  • 25:57 - The danger of self-reinforcing optimization loops

  • 28:28 - Anton, Aaron’s voice agent

  • 33:11 - The value and daily cost of a conversational thinking partner

  • 35:19 - Artifacts, durable reactions, and Alephic’s working model

  • 38:15 - Consulting, pitching, and feedback as an established interaction pattern

  • 40:11 - Smaller teams, smaller companies, and what organization design must retain

  • 41:45 - Persuasion, ground truth, and model sycophancy

  • 43:40 - Open source, authority, and hybrid decision systems

  • 47:00 - Letting data challenge strategy and prior leadership decisions

  • 48:52 - Applied preference and learning what leaders actually value

  • 50:32 - Embodied judgment, consistency, and two kinds of intelligence

  • 52:46 - Team Human and AI as a new tool for humans

Links & References

Aaron and his work

Organization design and agent systems

About Forward Deployed

Forward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned.

]]><![CDATA[Forward Deployed, Episode 8: The Factory Has To Prove It Works]]>https://www.forwarddeployed.com/p/forward-deployed-episode-8-the-factoryhttps://www.forwarddeployed.com/p/forward-deployed-episode-8-the-factoryTue, 21 Jul 2026 17:21:07 GMTJustin McCarthy joins me to talk about what happened after he told a team to stop writing code—and then discovered they had to stop reading it too.

Justin is the founder of Diffusion and the former co-founder and CTO of StrongDM. His team at StrongDM built one of the clearest examples of a working software factory: humans define goals and the shape of the feedback system, while agents do the implementation work. The provocative rule was no human-written code. The consequential discovery was that production moved too quickly for human code review, so trust had to move somewhere else.

That is where the conversation starts: if nobody is reading the code, how do you know the factory is building the right thing? We get into goals, loops, scenarios, expensive tokens from the real world, and Justin’s idea of a decision theater—an environment designed to help a person build conviction and make a judgment quickly.

From there we talk about the gap between wall time and token time, why desire may matter more than job title, what Attractor taught Justin about deterministic control around open-ended model calls, and why the right response to cheaper production is not a smaller P&L. It is a much larger ambition.

Key Topics Covered

  • The agentic moment: Why Justin dates the shift to Claude 3.5 Sonnet’s second release and Cursor’s YOLO mode, when software first started getting built from another room.

  • No human-written code: How a hard constraint forced the StrongDM team to rethink software production from first principles.

  • No human code review: Why production speed made source inspection infeasible and pushed trust into goals, feedback loops, scenarios, and external validation.

  • Goals and expensive tokens: Why the richest signal is often a real customer response and how to build cheaper proxies before paying for it.

  • Decision theaters: How multimodal models can turn future scenarios into interfaces where human judgment operates in seconds rather than weeks.

  • Token time versus wall time: What should flow automatically after a decision and where deliberate human cognitive latency still belongs.

  • Desire strongly: Why Justin thinks obsession and the ability to depict a desired future matter more than a particular professional background.

  • Language and prior art: How vocabulary, voice, computing concepts, and concrete implementation references help people evoke better agent behavior.

  • Attractor and deterministic control: Why context-window-sized work, explicit state, and model-judged transitions remain useful around open-ended model calls.

  • Discovery versus ordering: Why Justin prompts when he is discovering what he wants, but hands off a finished outcome document once the vision is clear.

  • Natural-language specifications: Why StrongDM published the shape of a harness rather than committing to maintain another open-source implementation.

  • Ambition over efficiency: Why cheaper production should make larger goals possible instead of merely shrinking costs.

Timestamps

  • 00:00 - Opening

  • 00:10 - Justin McCarthy’s introduction

  • 01:07 - From StrongDM and cybersecurity to the agentic moment

  • 02:33 - Why October 2024 was the real agentic threshold

  • 03:38 - Cursor’s YOLO mode and software built from another room

  • 08:10 - Claude Code and model-market-harness fit

  • 11:28 - Computation, companies, governments, and old management books

  • 13:06 - No human-written code becomes no human code review

  • 15:30 - Goals, loops, feedback, and definitions of done

  • 16:32 - Expensive tokens and measurements from the real world

  • 18:52 - Decision theaters and depicting possible futures

  • 23:47 - Price signals, competition, and how large companies wake up

  • 25:33 - Agent-written messages and why sending slop is disrespectful

  • 27:23 - Craft, identity, exhaustion, and hope

  • 28:18 - Software factories, software companies, and alignment

  • 29:44 - Who is best equipped to work with agents?

  • 31:38 - Desire strongly

  • 33:40 - Vocabulary, Midjourney, and the Gell-Mann amnesia problem

  • 34:59 - SICP, Redis, and speaking in the language of computation

  • 35:57 - Attractor, context windows, and deterministic control flow

  • 39:53 - Discovery mode versus ordering a known outcome

  • 40:37 - Throwaway web pages and decision interfaces

  • 43:53 - Never drag it back in: building the collaborative loop

  • 44:55 - Natural-language specifications and disposable harnesses

  • 47:14 - Deliberate cognitive latency and the Toyota Production System

  • 49:14 - The Goal, ambition, and why efficiency cannot be the goal

Links & References

Justin and Diffusion

Software factories and agent systems

Books and concepts

About Forward Deployed

Forward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned.

]]><![CDATA[Forward Deployed, Episode 7: The Diffusion Clock and the Conversion Clock]]>https://www.forwarddeployed.com/p/forward-deployed-episode-7-the-diffusionhttps://www.forwarddeployed.com/p/forward-deployed-episode-7-the-diffusionTue, 30 Jun 2026 16:26:18 GMTJames Cham joins me for what is basically one of our recurring AI freakout calls, recorded.

James is a partner at Bloomberg Beta and one of my favorite people to talk to when a new model or workflow suddenly makes the world feel slightly miscalibrated. Back in 2024, he and I recorded AI & The Enterprise with James Cham for the BRXND newsletter, which covered AI cycles, opinionated enterprise software, and where durable value might live. This conversation picks up from there. We started with Fable, because Fable forced a strange question: what if the best use of the frontier model is not writing the code, but deciding what work deserves which model in the first place?

Thanks for reading Forward Deployed! Subscribe to receive new episodes.

From there we get into the experience curve, building ahead, why better tickets make better models, the shift from MCPs to skills plus CLIs, and the way meetings change when everyone knows the transcript is becoming source material for agents.

The core question of the episode is the one James and I keep circling: what does the edge know months before the enterprise can see it, and how do you tell when diffusion has become real conversion?

Key Topics Covered

  • Fable as planner: Why the frontier model may be more valuable deciding the work than doing every step of the work.

  • Building ahead: Why fast-improving models make it risky to build only for what works today.

  • Experience curves and TSMC: How planning for future yield changes what looks rational in the present.

  • Tickets as agent ergonomics: Why “good for the model” and “good for the human developer” are starting to converge.

  • Skills, CLIs, and MCPs: Why Noah has moved toward deterministic skill calling and CLI-backed knowledge work.

  • Company brains: How call transcripts, deals, contacts, and structured internal data become the substrate for AI work.

  • AI-native meetings: Live artifacts, recorded prompts, and the new habit of saying the important thing out loud because the model needs to hear it too.

  • Edge users: Why people like Justin McCarthy, Jesse Vincent, Ethan and Lilach Mollick, and highly structured teams see new patterns first.

  • Lab-to-enterprise diffusion: Why labs do not see every use case, and why people outside the labs have an advantage from using heterogeneous models.

  • Bottlenecks, O-rings, and Amdahl’s law: Why the slowest remaining step in the loop matters more than average task exposure.

  • Token maxing: Why pushing people to use more tokens can be a forcing function for exploration, even if the metric eventually gets gamed.

  • Small sparks: James’s investor lens for watching tiny edge behaviors before they become aggregate numbers.

  • What James is reading: C. Thi Nguyen on games and Jon McNeill on Tesla, management consulting, and operational discipline.

Timestamps

  • 00:00 - James Cham joins for a regularly scheduled AI freakout call

  • 02:00 - Fable, one-shot Joust, and what changed in one week

  • 05:00 - Fable as planner, not just code writer

  • 07:00 - Experience curves, Morris Chang, and pricing for future yield

  • 10:15 - Building ahead and planning for the models of 2027 or 2028

  • 13:35 - Tickets, model routing, and why solving the wrong problem is the real failure mode

  • 17:00 - Skills, CLIs, MCPs, Codex, Claude Code, and the company brain

  • 25:00 - Command lines versus GUIs for agent work

  • 28:00 - Meetings that produce live artifacts

  • 31:30 - Recording meetings so agents can recover prompts, scopes, and decisions

  • 33:00 - Justin McCarthy, Jesse Vincent, and empathy for agents

  • 36:15 - Documentation culture, AI scribes, and making implicit work explicit

  • 38:10 - The diffusion timeline from labs to edge users to enterprise

  • 42:00 - Heterogeneous models and why the labs cannot see everything

  • 44:45 - Bottlenecks, O-rings, Amdahl’s law, and the 0.01 percent problem

  • 45:15 - Token maxing as a forcing function for exploration

  • 49:20 - James’s current reading list: C. Thi Nguyen and Jon McNeill

Links & References

James

Prior James conversations

Concepts and papers

Tools and systems discussed

About Forward Deployed

Forward Deployed is a podcast about the intersection of AI, software development, and the enterprise. Subscribe if you are trying to understand what it means to build AI systems that work in the real world: systems with context, evaluation, workflows, failure modes, and some theory of how people and agents stay aligned.

]]><![CDATA[Forward Deployed, Episode 6: Market Mechanisms for Agents]]>https://www.forwarddeployed.com/p/forward-deployed-episode-6-markethttps://www.forwarddeployed.com/p/forward-deployed-episode-6-marketWed, 27 May 2026 11:50:42 GMTWelcome to episode six of Forward Deployed. Noah sits down with Rohit Krishnan, author of Strange Loop Canon, to talk about what happens when we take the word “agent” seriously.

Rohit brings together AI, markets, economics, organizational theory, and simulation. The conversation moves from principal-agent problems to enterprise world models, data-first ontologies, MarketBench, model self-knowledge, and the harder question underneath all of this: how do we build agentic systems that can coordinate, learn, and act inside messy organizations?

Key Topics Covered

  • Agents as an economic problem: Why principal-agent theory, markets, and organizational design matter for AI agents

  • Rohit’s path: Startups, markets, McKinsey, investing, AI, and the long-running attempt to connect economics with technology

  • Enterprise world models: Why organizations may be a richer substrate for world models than the physical or visual domains alone

  • Data-first ontologies: How company histories, email, Slack, docs, GitHub, Jira, and other streams can produce a live model of how work actually happens

  • Small models and simulations: Why Rohit is experimenting with small JEPA-style models and daily retraining instead of treating frontier LLMs as the whole system

  • Counterfactuals and prediction: How world models can help answer questions like whether a customer will renew, how to respond to a contract, or which actions are likely to produce which outcomes

  • MarketBench: Why Rohit and Andrey Fradkin built a benchmark for asking whether AI agents can bid on their own capabilities and costs

  • Model self-knowledge: Why Gemini tends to overbid, GPT tends to underbid, Claude is directionally better, and none of them are well calibrated enough yet

  • Memory and onboarding: Why agents still feel like brilliant day-one employees, and why markdown files, project context, and memory systems are only partial answers

  • Specs, workflows, and co-evolution: Why real software work is not just satisfying a fixed spec, but helping the spec and the deliverable evolve together

  • Kids and AI: How to help children use AI as a tool for creation and discovery without outsourcing their own taste, voice, or imagination

Timestamps

Note: timestamps are approximate

  • 00:00 - Introduction: Rohit Krishnan, Strange Loop Canon, and market mechanisms for agents

  • 00:55 - Rohit’s background across AI, economics, startups, consulting, investing, and simulation

  • 04:30 - Why “agents” are an economic and organizational problem

  • 09:55 - Why technology wants answers while economics designs mechanisms

  • 11:00 - Enterprise world models and the limits of traditional digital twins

  • 14:00 - Building organizational world models with small JEPA-style systems

  • 16:15 - Public datasets, Enron, startup data, and daily decision support

  • 17:20 - Modeling companies through email, Slack, docs, GitHub, Jira, and Confluence

  • 20:35 - Data-first ontologies and why static top-down ontologies break as companies change

  • 24:10 - Counterfactual questions, model priors, and where LLMs regress toward the median

  • 27:00 - Frontier models, unknown unknowns, and why expertise still shapes the questions worth asking

  • 32:30 - MarketBench and using markets to coordinate AI agents

  • 35:35 - How model auctions work: success probability, token cost, bids, and allocation

  • 37:05 - Model calibration: Gemini overconfidence, GPT underconfidence, and Claude’s relative advantage

  • 40:00 - Whether prior performance data can improve model self-knowledge

  • 41:40 - Agents as brilliant day-one employees and the limits of current memory systems

  • 44:35 - Onboarding, markdown files, context windows, and the need for better mechanisms

  • 47:00 - Misalignment in coding agents and why tests do not solve the whole problem

  • 48:50 - Software companies, software factories, and rediscovering The Mythical Man-Month

  • 50:50 - Why requirements, specs, and deliverables have to co-evolve

  • 51:30 - Using world models to discover workflows and skills inside an enterprise

  • 53:00 - Kids, AI, creation vs. consumption, and preserving individual voice

Links & References

Core References

Concepts & Frameworks

  • Principal-agent problem - The economic framing Noah and Rohit return to when talking about AI agents

  • MarketBench - Benchmarking whether agents can estimate their own success probability and task cost

  • SWE-bench - The software engineering benchmark used as one task source for MarketBench

  • JEPA / I-JEPA - Joint Embedding Predictive Architecture and world model context

  • Enron email dataset - Public organizational dataset Rohit discusses as a testbed for enterprise world models

  • The Mythical Man-Month - The classic software engineering reference Noah invokes near the end

Previous Episodes

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands and enterprises build custom AI systems.

Rohit Krishnan is an independent researcher and writer whose work spans AI, economics, markets, organizational theory, and simulations. He writes Strange Loop Canon.

Connect with the Hosts

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

Newsletter: Sign up for updates at forwarddeployed.com

]]><![CDATA[Forward Deployed, Episode 5: Aligning Agents]]>https://www.forwarddeployed.com/p/forward-deployed-episode-5-aligninghttps://www.forwarddeployed.com/p/forward-deployed-episode-5-aligningThu, 07 May 2026 13:37:11 GMTWelcome to episode five of Forward Deployed. Noah sits down with Taylor Pearson to continue the conversation about how we align agents, and why the best models may come from outside traditional software engineering.

Taylor brings a background that cuts across history, internet businesses, The End of Jobs, risk parity investing, complexity science, and recent deep work with Claude Code. The conversation moves from firms and transaction costs to Toyota, military doctrine, memory, skills, and the problem of getting agents to work toward the right goal.

Key Topics Covered

  • Aligning agents: Why the episode starts with the question of how to align agents and what engineering can borrow from organization design, markets, and systems theory

  • Taylor’s path: From history, SEO, ecommerce, and The End of Jobs to finance, risk parity, complexity science, and AI work

  • Claude Code as a turning point: Why agentic command-line systems felt more transformative for Taylor than chatbot workflows

  • Historical analogies for AI: Electricity, factory design, Toyota, and the need for a new pattern language for agentic work

  • Companies as agentic systems: Why firms may be a more useful model than deterministic software systems for coordinating agents

  • Junior employees and agents: The familiar failure mode where the work is done well but aimed at the wrong problem

  • Bottlenecks and specs: Why fixing pull requests is not the whole game, and why the bottleneck may move upstream into briefs, specs, and coordination

  • Pace layers and skills: Best practices, project architecture, plans, code, and how different layers of a system move at different speeds

  • Memory and context: How skills, files, and externalized memory help agents carry useful context between sessions and systems

  • Jobs and firm boundaries: How AI changes the calculus around what belongs inside a company, what gets outsourced, and which roles collapse together

  • Writing, investing, and complex systems: Why some domains resist fixed best practices because everyone adapts to the same patterns

Timestamps

Note: timestamps are approximate

  • 00:00 - Introduction: Taylor Pearson, complexity theory, organizations, and aligning agents

  • 01:15 - Taylor’s path from history to SEO, ecommerce, The End of Jobs, finance, and AI

  • 03:30 - The GFC, The Black Swan, markets, systems thinking, and transaction costs

  • 07:00 - Claude Code, Codex, and the agentic workflow shift

  • 13:45 - Historical analogies for AI, electricity, factories, and pattern languages

  • 18:00 - Why companies may be the better model for agentic systems than software systems

  • 20:45 - Organization metaphors, the Toyota Production System, and agents as junior employees

  • 24:00 - Bottlenecks, specs, briefs, and the coordination work before code

  • 27:05 - Mission alignment, pace layers, skills, best practices, and architecture

  • 32:20 - Cynefin, best practices, good practices, and emergent practices

  • 34:50 - Boyd’s OODA loop, Schwerpunkt, and shared objectives

  • 39:05 - Memory, role boundaries, and what changes inside and outside the firm

  • 43:25 - Externalized memory, skills, and context across systems

  • 46:25 - Generalization, AI writing, de-slopping, and verifiable rewards

  • 49:15 - Writing, investing, complex systems, and the Maginot Line problem

  • 51:20 - Closing thoughts

Links & References

Core References

Concepts & Frameworks

Tools & Platforms

  • Claudesidian - Noah’s Obsidian/Claude framework

  • OpenAI Codex - The competing agentic coding interface discussed in the episode

  • Obsidian - Note-taking and memory system context for agent workflows

  • Alephic - Noah’s AI consulting company

Previous Episodes

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands and enterprises build custom AI systems.

Taylor Pearson is an author and investor whose work spans entrepreneurship, markets, complexity theory, and AI. He is the author of The End of Jobs.

Connect with the Hosts

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

Newsletter: Sign up for updates at forwarddeployed.com

]]><![CDATA[A Timeline of AI Progress]]>https://www.forwarddeployed.com/p/a-timeline-of-ai-progresshttps://www.forwarddeployed.com/p/a-timeline-of-ai-progressTue, 05 May 2026 16:46:28 GMTI originally put this slide together for the September 2025 edition of BRXND. It is a timeline of what I would consider the major milestones in AI over the last five years. The orange ones are the things I think are worth paying attention to. It was designed to scale as best I could with my limited Figma skills.

There are two things that should stand out:

Thanks for reading Forward Deployed! Subscribe for new posts and episodes at the intersection of AI, engineering, and the enterprise.

  1. There are fewer moments than you would assume over the last five years. That’s because I purposely left out every small model update and focused on the bigger events.

  2. There are only five highlighted moments. Despite arguments to the contrary and the never-ending parade of model releases, I genuinely believe AI has undergone only a few major changes over the last five years.

My five moments with their defenses:

  1. November, 2021—GPT-3 API goes GA: This one is easy for me. We could draw the line in the sand almost anywhere after the Attention is All You Need paper, but to me, putting these things in the general public’s hands (albeit in API form) is a good demarcation point. There are still the “I’ve been doing AI for years” people complaining that ML is AI, but what’s possible before and after the GPT-3 API is very different.

  2. June, 2022—GitHub Copilot goes GA: it’s easy to take for granted now, particularly with the conversations happening around uptime and GitHub, and the eventual direction Microsoft took the Copilot brand, but that initial autocomplete product in VS Code felt like magic and was the first real productization of AI.

  3. November, 2022—ChatGPT Launch: This is the easiest one, and everyone likes to talk about it. Lots of us were building chatbots on our own, and this felt like such an obvious next step. Funny enough, this also immediately shifted Copilot use because while autocomplete was cool, chat turned out to be the killer app for coding (a fact Copilot seemed to miss and Cursor eventually ate their lunch on).

  4. September, 2024–o1 Reasoning: The Google chain of thought paper came out in early 2022 and showed that adding reasoning to prompts significantly improved the models’ ability to reason, but it took two and a half years for OpenAI to build it into a model. o1 was big and slow, but set the groundwork for everything that followed. Though we didn’t realize it at the time, the real magic of these reasoning models wasn’t just that they were much better thought partners. Function calling was introduced to models in June 2023, but before reasoning models, it was incredibly inconsistent—better for demos than for real work. Reasoning changed that, allowing the model to plan its function calls before executing them.

  5. May, 2025–Claude Code: finally, we have Claude Code, which celebrates its first birthday this month. If o1 made function calling work, Claude Code wrapped it in an agent loop: inspect the repo, decide what to do next, call a tool, read the result, and keep going. The tools themselves were simple UNIX commands, deeply covered in the pre-training data thanks to half a century of UNIX documentation. While lots of people believe that Opus 4.7 unlocked the harness, I think the causality goes the other way.

Despite how easy (and fun) it can be to get lost in each new model release or tool update, the reality is that most of it is just gradual improvement. That’s not to say it’s not tremendously valuable—GPT 4o unlocked ChatGPT in new ways—but those weren’t step changes in what is possible, they were the kind of slow progress that we always find hard to measure.

To that end, I have a few observations and thoughts from this list.

First off, each of these step changes is still very much building on the previous one. ChatGPT doesn’t happen without GPT-3, just like Claude Code doesn’t happen without o3. Reasoning models themselves are obviously evolved from prompting techniques. That can make AI progress feel Darwinian, but W. Brian Arthur’s point in The Nature of Technology is more specific: technologies evolve by combination. New things are assembled out of existing components and the phenomena they harness; sometimes better variations win, and sometimes a new principle arrives that makes the old family tree less useful. The jet engine isn’t just a better propeller. His focus is mostly hardware, not software, but it still makes me wonder if we should expect more radical changes, or maybe we’re just settled into this architecture, and that’s how we should expect innovation to happen. Here’s how Anthropic co-founder Jack Clark put it recently:

As a field, AI moves forward on the basis of doing ever larger experiments that utilize more and more inputs (e.g, data and compute). Every so often, humans come up with some paradigm-shifting idea which can make it dramatically more resource efficient to do things - a good example here is the transformer architecture and another is the idea of mixture-of-expert models. But mostly the field of AI moves forward through humans methodically going through some loop of taking a well performing system, scaling up some aspect of it (e.g, the amount of data and compute it is trained on), seeing what breaks when you scale it up, figuring out the engineering fix to allow it to scale, then scaling it again.

Another interesting observation is that image and video models are mostly missing on this timeline. I don’t quite know what to make of these models, and that’s part of the reason I’m writing this post. Every time a new step change in capability comes along (like Nano Banana or, more recently, GPT Image 2.0), we see people say everything is going to change, and then mostly not a lot changes. As practitioners of AI and marketing, we are making good use of the current crop of models with a variety of customers for a variety of use cases, but it feels like the Copilot/ChatGPT/Claude Code moment just hasn’t arrived yet. Obviously, diffusion as an approach is amazing and probably deserves a place on the list, but the leaps feel much more gradual and make it hard to draw conclusions. With all that said, the release of GPT Image in March 2025 caused an explosion of usage in ChatGPT.

To that point, maybe the most fundamental takeaway from the timeline is that the real leaps in usage come from a kind of weird alchemy between model, market, and harness. The model has to be good enough to do the job, the harness has to expose that capability in a form people can actually use, and the market has to be in the right place to see the full value. Each one of these episodes caused a step change in token demand. Anthropic’s own annualized run-rate numbers make the point: the company went from approximately $9 billion at the end of 2025 to more than $30 billion by early April 2026.

Sholto Douglas, an Anthropic researcher focused on scaling reinforcement learning, made a version of this point on a 2025 episode of the Dwarkesh Podcast: Cursor had been around for a while, but with Claude 3.5 Sonnet, “the model was finally good enough that the vision they had of how people would program, hit.”

That’s why the causation is so hard to pin down. Lots of people are sure that Claude Code exploded in December because of the release of Opus 4.7. As a relatively early adopter of CC, I’m a lot more skeptical. Many of us were getting tremendous value out of the harness in June and July. I think it’s much more likely that the real thing that happened in December is that a bunch of people just had more time to give the tool an honest go, and when they did, they were blown away.

Claude Code creator Boris Cherny calls this “product overhang.” The model’s capabilities often remain untapped until the right code comes along to unlock them. What I think this timeline adds is that there is a market overhang, too. The model can be good enough, and the harness can exist, but the market also has to be ready to notice, care, and change behavior. The highlighted moments are when model, harness, and market meet.

So what comes next? I don’t know. The three things I keep coming back to are reliable computer use, secure mobile agentic capability, and real document collaboration. I don’t know if any of them are the thing, but they all feel like potential unlocks for the next step change in token demand.

Thanks for reading Forward Deployed! Subscribe for new posts and episodes at the intersection of AI, engineering, and the enterprise.

]]><![CDATA[10 Links for Saturday, May 2]]>https://www.forwarddeployed.com/p/10-links-for-saturday-may-2https://www.forwarddeployed.com/p/10-links-for-saturday-may-2Sat, 02 May 2026 13:50:21 GMTYou’re getting this email as a subscriber of ForwardDeployed, a newsletter at the intersection of AI, engineering, and the enterprise.

Subscribe now


Looking for something to read this weekend? Here’s 10 quick hits:

  1. Taylor Pearson (who will be on the next episode of the podcast with me) uses Goldratt’s The Goal/theory of constraints to question parallel agent usage: “I suspect a lot of agent usage right now is the same fallacy at higher resolution. Running 20 Claude Code sessions in parallel can feel productive because something is always happening. But, if the bottleneck in your work is judgment about what’s worth doing, more agents just generate more output for you to wade through.” (If you haven’t read The Goal, it’s highly recommended. There’s even a graphic novel version.)

  2. GitHub’s Maggie Appleton hits on a point I’ve been making a lot: We’ve known code wasn’t the bottleneck for 50 years (see: Mythical Man Month) … “Implementation is rapidly becoming a solved problem, right? Writing code is now fast, it’s getting cheap, and quality is going up and to the right. The hard question is no longer how to build it. It’s should we build it.”

  3. Codex Desktop is very good. Flue looks intriguing: “Not another SDK. Build powerful, autonomous agents with Flue’s programmable TypeScript harness. Write once, deploy anywhere.”

  4. Very worth reading the Claude Code postmortem from Anthropic. Lots of lessons about the way small changes can impact agentic systems.

  5. Interesting to track some of the follow-ups to the Jensen/Dwarkesh conversation. I particularly liked this ChinaTalk piece.

  6. It’s cool that OpenAI released this little PII redaction model.

  7. I’d love to see DESIGN.md catch on … curious to see what happens.

  8. Steve Yegge (of Stevey’s platform rant fame) punched back when Google folks said he was wrong about internal usage of Gemini models. No clue what’s real/not real here, but following the way the Mag7 is using AI and how different each company’s approach is is fun to watch.

  9. I’ve been thinking a lot about my variance spectrum concept recently and how it relates to the spectrum of testing, linting, acceptance criteria, etc., that we integrate into agentic workflows. I put up a page to cover off on the basics, as it’s a model I continue to come back to.

  10. Aligned agents still build misaligned organizations, from Rohit Krishnan (coming on the podcast soon) is fun. “So while each role did things that made sense to them, they ended up in a spot where they’re clearly misleading folks. The headline failure here is that the company’s billing system ends with the SLA clock stopped when the underlying world clearly says the outage stayed past the trigger when credit and review should have opened. (That is the value the billing system would return to say, an auditor.)”

That’s it for now. Have a great weekend.

— Noah

Thanks for reading Forward Deployed! Subscribe and share.

]]><![CDATA[Forward Deployed, Episode 4: The Special Forces Model]]>https://www.forwarddeployed.com/p/forward-deployed-episode-4-the-specialhttps://www.forwarddeployed.com/p/forward-deployed-episode-4-the-specialSat, 21 Mar 2026 20:59:34 GMTWelcome to episode four of Forward Deployed. Noah sits down with Chris Papasadero to explore the deep parallels between Special Forces operations, enterprise software deployment, and creative direction—and what all of it means for building AI agents that actually work in the real world.

Key Topics Covered

  • The Forward Deployed Engineer (FDE) model: How Palantir’s approach to embedding technical experts mirrors Special Forces doctrine

  • Force multiplication: Why Green Berets are designed to produce outsized output from minimal input — and what that means for AI agents

  • Comfort with ambiguity: The Special Forces selection pipeline, the Star Course, and why a 2% selection rate tests for the right traits

  • Cultural embedding: Why Palantir contractors in Afghanistan succeeded by understanding the operational environment, not just the software

  • Organizational structure and bureaucracy: NCO-led detachments, pushing planning to the lowest level, and the OSS Simple Sabotage Field Manual

  • Three layers of alignment: Shared cultural values, doctrine, and experience — Chris’s framework for aligning both teams and AI agents

  • Second and third-order effects: Why software engineering (like warfare) is a creative pursuit, not a six sigma factory process

  • Showrunners and creative direction: The role of holding both operational and creative vision across a large, autonomous team

  • Warhol Factory vs. Ford Factory: Why creative production is a better analogy for agentic systems than industrial automation

Timestamps

Note: timestamps are approximate

  • 00:00 - Introduction and the origin of “Forward Deployed”

  • 01:30 - Chris’s background: Special Forces and Palantir

  • 05:00 - The Forward Deployed Engineer (FDE) model at Palantir

  • 08:30 - Cultural embedding: Why Palantir worked in Afghanistan

  • 12:00 - Special Forces as force multipliers

  • 15:00 - The selection pipeline and comfort with ambiguity

  • 18:30 - The Star Course: Navigating alone without external guidance

  • 21:00 - Maintaining the big picture in the fog of war

  • 25:00 - Organizational structure: NCO-led detachments and decentralized planning

  • 29:00 - Planning for failure: Incorporating contingencies from the start

  • 33:00 - The Simple Sabotage Field Manual and organizational bureaucracy

  • 37:00 - Applying military frameworks to AI agents

  • 41:00 - Three layers of alignment: Values, doctrine, and experience

  • 45:00 - Second and third-order effect analysis

  • 49:00 - Software engineering as a creative pursuit

  • 52:00 - Showrunners, dailies, and creative direction

  • 56:00 - The Warhol Factory model for agentic systems

  • 59:00 - Wrap-up and key takeaways

Links & References

Core References

Concepts & Frameworks

  • Special Forces (Green Berets) — Force Multiplication doctrine

  • The Star Course — Special Forces land navigation assessment

  • NCO-led detachments — Decentralized command and planning

  • Andy Warhol’s Factory — Creative production model

Related Content

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.

Chris Papasadero is this episode’s guest, bringing deep experience at the intersection of Special Forces operations, defense technology, and enterprise software deployment.

Connect with the Hosts

Noah Brier: LinkedIn | X/Twitter

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

]]><![CDATA[Forward Deployed, Episode 3: Context Engineering]]>https://www.forwarddeployed.com/p/forward-deployed-episode-3-contexthttps://www.forwarddeployed.com/p/forward-deployed-episode-3-contextSat, 27 Dec 2025 00:10:17 GMTWelcome to episode three of Forward Deployed. Noah and Lance dive deep into context engineering—the art and science of filling context windows with just the right information for agents to take the next action.

Key Topics Covered

- Context engineering: Why Karpathy’s term matters more than prompt engineering for agents

- Three core techniques: Reducing context, isolating context, and offloading context to file systems

- Skills vs MCPs: Why progressive disclosure beats loading everything into context

- Claude Diary: Building agent memory through reflection and evolving CLAUDE.md

- Why subagents should isolate context, not anthropomorphize org charts

- Production patterns from Manus: Compaction, file system offloading, and sandbox architecture

- The convergence of agent primitives: Read, write, reduce, and recombine

- Why treating agents like humans works: Dual-use tools and new coworker onboarding

Timestamps

- 00:10 - What is context engineering and why should we care?

- 00:37 - Karpathy’s definition: Filling context windows with just the right information

- 01:15 - Context engineering vs prompt engineering: Tools bring context too

- 02:27 - Three buckets: Reducing, isolating, and offloading context

- 04:30 - Dynamic context loading: Skills as just-in-time context

- 06:38 - Skills as context offloading: Progressive disclosure of tools

- 09:15 - Sandboxes beyond Manus and Claude Code: Application integration patterns

- 12:12 - Context isolation through subagents: Not org charts

- 14:41 - Using isolation as a feature: Test-driven development with blank slate agents

- 16:33 - Real-world subagent challenges: Shared file systems and context bottlenecks

- 20:47 - Claude Diary: Automatic memory through session reflection

- 22:53 - CLAUDE.md bloat: Reducing unnecessary words like Strunk and White

- 28:06 - Dual-use tools: Why Claude Code uses bash, grep, and human-readable commands

- 31:02 - Skills discovery problems: From manual search to automated finding

- 34:22 - Agent primitives: Read, write, reduce, and creative recombination

- 36:32 - Tool search and action space design: How to find the right function

- 40:50 - Hooks as determinism: Injecting code into agent loops

- 41:41 - Skills everywhere: ChatGPT’s progressive disclosure discovery

- 43:12 - Nano Banana: Text on images unlocks new agentic workflows

Links & References

Core References

Technical Resources

Tools & Frameworks

Related Content

- 🎙️ Karpathy on Dwarkesh Podcast - Discussion of AI development principles

- 📚 The Elements of Style by Strunk and White - “Reduce unnecessary words” as principle for CLAUDE.md

- 📄 The Bitter Lesson by Richard Sutton - General methods that leverage computation

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.

Lance Martin is a founding engineer at LangChain, where he works on developer tools for building AI applications.

Connect with the Hosts

- Noah Brier: LinkedIn | X/Twitter

- Lance Martin: LinkedIn | X/Twitter

* * *

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

]]><![CDATA[Forward Deployed, Episode 2: Claude Code Skills and the Progressive Disclosure Problem ]]>https://www.forwarddeployed.com/p/forward-deployed-episode-2-claudehttps://www.forwarddeployed.com/p/forward-deployed-episode-2-claudeMon, 17 Nov 2025 03:26:07 GMTWelcome back to episode 2 of Forward Deployed. This week Noah and Lance dive deep into Claude Code skills, a deceptively simple feature that’s changing how we think about building AI agents. Noah walks through the Alephic CLI he’s been building and reveals a wild hook-based routing system using Cerebras at 3,000 tokens per second.

Plus: Why Andreessen thinks AI isn’t the Internet redux.

Key Topics Covered

  • Claude Code skills and the progressive disclosure problem

  • How Noah built a hook to solve the 10% skill hit rate

  • Tier 1 vs Tier 2 action space: Why Manus and Anthropic converged on the same architecture independently

  • 3,000 tokens per second: Using Cerebras Llama 120B as an invisible routing layer for every user message

  • The MCP/skill/command convergence: Are they all just different flavors of the same primitive?

  • Vision feedback loop: Turning Gemini into a Pentagram creative director to critique Claude’s web designs

  • Andreessen’s “computers v2” thesis: Why AI isn’t the Internet redux, it’s the first von Neumann architecture replacement in 80 years

  • Git workflows with Claude Code: Why Lance and Noah don’t worry about merge conflicts anymore

Timestamps

  • 00:11 – Welcome to episode 2 on Claude Code skills

  • 00:28 – What are Claude Code skills? Not much more than a folder full of prompts

  • 01:10 – Lance: Skills as “instructing a new hire” with subfolder instructions

  • 01:25 – Simon Willison and Jesse Vincent’s “superpowers” discovery

  • 04:45 – Noah demos the Alephic CLI skill directory structure

  • 07:32 – The hook-based skill search system using Cerebras

  • 08:19 – Lance reveals: YAML front matter always loads into system prompt

  • 09:32 – The 10% skill hit rate problem when you have 10+ skills

  • 10:08 – Cerebras Llama 120B running at 3,000 tokens per second for invisible routing

  • 13:17 – The universal pattern: Everyone’s trying to control context

  • 15:59 – Tier 1 vs Tier 2 action space: Manus and Anthropic converge independently

  • 21:29 – Noah’s big challenge: Getting models to consistently look for skills

  • 28:04 – Hit rate drops to 10% even with only 4–5 skills

  • 30:54 – Could progressive disclosure become built-in like chain of thought?

  • 34:06 – Lance on externalizing context to file systems

  • 35:15 – Vision feedback loop: Gemini as Pentagram creative director critiquing Claude’s designs

  • 37:57 – Andreessen: AI isn’t the Internet, it’s computers v2

  • 42:08 – Why Noah and Lance don’t worry about merge conflicts anymore

Links & References

Core References

Tools & Frameworks

Blog Posts

Companies Mentioned

  • Anthropic – Claude Code creator

  • LangChain – Where Lance is a founding engineer

  • Alephic – Noah’s AI consulting company

  • Pentagram – Design agency Noah used as creative director persona

Development Tools

  • Obsidian – Note-taking use case for Claude Code

  • Git Work Trees – How the team manages multi-branch development

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company helping brands build custom AI systems. He writes about AI strategy and implementation.

Lance Martin is a founding engineer at LangChain, where he works on developer tools for building AI applications.

Connect with the Hosts

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

]]><![CDATA[Forward Deployed, Episode 1: The Bitter Lesson]]>https://www.forwarddeployed.com/p/forward-deployed-episode-1-the-bitterhttps://www.forwarddeployed.com/p/forward-deployed-episode-1-the-bitterMon, 03 Nov 2025 14:15:06 GMTWelcome to the first episode of Forward Deployed (YouTube), a podcast exploring the intersection of AI, software development, and the enterprise.

We’re very excited to have you join us as we tackle the wild world of Forward Deployed engineering. We hope to make this a roughly bi-weekly show and look forward to inviting guests in the future. The idea is to dive deep into the realities of making this stuff work in companies, building on our expertise as builders both inside and outside the enterprise.

Thanks for listening, and please let us know what you think.

Thanks,

Noah & Lance

Subscribe to Forward Deployed to be the first to hear about new episodes and articles.

In this inaugural episode, hosts Noah Brier (Co-founder, Alephic) and Lance Martin (Founding Engineer, LangChain) dive deep into one of AI’s most controversial ideas: The Bitter Lesson. They unpack Richard Sutton’s famous essay, debate whether LLMs truly follow its principles, and explore what this means for anyone building with AI today.

Watch on YouTube

Key Topics Covered

  • The Bitter Lesson: Why more compute beats clever algorithms (or does it?)

  • Richard Sutton’s surprising take on why LLMs aren’t “bitter lesson pilled”

  • The evolution from CNNs to transformers through Lance’s journey from Stanford to Uber’s self-driving program to LangChain

  • Chain of thought prompting vs reasoning models - why your prompts might be breaking

  • The real challenges of enterprise AI adoption

  • Why ICs are adopting AI faster than managers

  • Building for imperfection: Why optimizing for today’s models is a mistake

Timestamps

  • 00:00 - Introductions and backgrounds

  • 00:53 - Lance’s journey: Stanford PhD to Uber self-driving to LangChain

  • 02:49 - Noah’s path from marketing to AI obsession

  • 04:04 - What “forward deployed” really means

  • 09:04 - The Bitter Lesson explained

  • 11:31 - Why Sutton thinks LLMs aren’t following the bitter lesson

  • 23:09 - Chain of thought prompting and the reasoning model revolution

  • 24:19 - Building for future models, not current ones

  • 45:20 - ICs vs managers in AI adoption

About the Hosts

Noah Brier is co-founder of Alephic, an AI consulting company working with enterprise clients like PayPal, EY, Meta, and Amazon on AI-powered content intelligence and competitive analysis. Previously founded and sold Percolate (marketing tech). He also runs the BRXND conference series focused on marketing and AI.

Lance Martin is a founding engineer at LangChain with a PhD from Stanford. Former computer vision lead for Uber’s self-driving truck program.

Links & References

Core References

Related Podcast Appearances

Blog Posts from the Hosts

Connect with the Hosts

Subscribe for weekly episodes exploring how AI is actually being deployed in the real world.

Newsletter: Sign up for updates at forwarddeployed.com

]]>