James 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?
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.
