The Messy Middle of AI in Education: Panic, Promise, and What Comes Next

Every company says its data is a strategic asset. Then many of them send that data to the same handful of frontier models their competitors can call. The answers can be good. The intelligence still never becomes something the company owns. In this episode of Talking AI, Matt Paige sits down with Manos Koukoumidis, cofounder and CEO of Oumi. Before Oumi, Manos led GenAI at Google Cloud and bootstrapped the Cloud PaLM effort that later moved into DeepMind as Gemini. He left to build what he calls pretty much the opposite: a platform that helps any enterprise create, deploy, and continuously improve its own specialized models. His rule is simple. Rent what is generic. Build and own what differentiates you or what costs you the most. Manos explains where that rule holds, why a bank should use Claude Code for coding but own the model that processes its mortgages, and why he thinks owning your intelligence will look obvious two years from now. In this episode, you’ll hear about: The three reasons to own your AI: differentiation, economics, and control Why frontier models used for narrow tasks are a Swiss Army knife you overpay for The early PaLM customer who asked for the model weights, and what that taught Manos Building a ChatGPT-style chatbot at Microsoft in 2016, years before transformers took over A decision tree for when to rent, route, fine-tune, or train Why Kirkland & Ellis decided to build its own legal AI A live demo: a fine-tuned Qwen model that beats Sonnet on a bank ticket classifier in about 20 minutes of human effort Turning production failures into the next training run in four clicks Why Oumi is open core, and the four assets an enterprise needs to avoid lock-in How a small AI-native team works: function collapse, design systems for Claude, and no code reviews for code you don’t understand Harness vs. model, and why you should not forget to train the brain The Three Prompts, a new segment on every Talking AI episode

Ask almost anyone whether AI made them faster, and the answer is an immediate yes. Ask whether it made their team faster and the answer gets vague. All that productivity is pooling inside individual chat windows — private context, private memory, private wins — while the team around each person moves at roughly the old speed. The tools got extraordinary. The seam between them and everybody else did not. In this episode of Talking AI, Matt Paige sits down with Lane Shackleton, Head of Superhuman Docs and the product leader who spent more than a decade building Coda, now rebuilt as Superhuman Docs inside the Superhuman Suite. Lane’s diagnosis is structural rather than cultural: chat tools and collaboration tools grew up under opposite design constraints, and they have not yet unified in any meaningful way. His answer is what he calls the last mile of AI — bringing agents to where people already work, instead of waiting for someone to decide it is time to use AI. The conversation covers why the chat window was always a soloist tool, what shared team context changes about how agents behave, the July 8 launch that turned Coda into Superhuman Docs, how product, design, and engineering roles are collapsing into one another, where the bottleneck moved once code got cheap to write, and how you partner with the same labs you compete with. In this episode, you’ll hear about: Why chat tools and collaboration tools grew up under opposite design constraints, and what that cost teams. The board meeting that pushed Coda into AI, and the weekend of demos that followed. Why having to decide it is time to use AI is a product failure, not a user problem. The context tax teams pay in copy/paste, and what shared context does instead. Why individual memory breaks down the moment a second person needs to see it. Using an MCP to keep a team’s decisions continuously updated from meeting notes. What it felt like to rebuild a beloved product under a new name in the middle of a platform shift. The case for a big-bang launch over a phased rollout. AI Views, and what beta users built that nobody predicted. How product, design, and engineering roles are collapsing into each other. Why the bottleneck moved to review the moment code got cheap. Let the makers make — and the point where someone has to codify what worked. --- Key Moments 00:01:48 — Two tool families that grew up apart: chat windows and collaboration tools 00:03:32 — The board meeting, Reid Hoffman, and Coda’s early look at the OpenAI API 00:06:11 — What a vision video is, and why prototypes beat blog posts 00:07:56 — Why having to think “it’s time to use AI” is a failure mode 00:11:20 — The context problem: copy/paste, thin slices, and memory that vanishes 00:13:00 — From decision logs to MCP: keeping a team’s memory continuously updated 00:15:01 — Coda to Grammarly to Superhuman: what the transition actually felt like 00:17:58 — Why July 8 was a big bang instead of a phased rollout 00:18:59 — AI Views explained: prompt your way on top of a dataset 00:20:58 — Low floor, high ceiling, and software that feels personal 00:24:05 — Product, design, and engineering roles collapsing into each other 00:26:30 — AI-native development: the team with no planning process 00:27:52 — Where the bottleneck moved: machines or humans reviewing the code 00:30:17 — Partner or threat? Working with the labs you also compete with 00:34:04 — Human-generated and machine-generated work have to get married somewhere 00:37:24 — Let the makers make, and why play beats mandates 00:43:31 — The end-of-day sweeper, and teaching his kids AI with homemade games

AI got very good at coding first, and the reason is less flattering than it sounds. Coding is work where the machine can check its own answer. The test passes or it doesn’t. The build compiles or it doesn’t. Almost nothing else people do all day comes with a test suite — strategy, brand voice, a hiring call, a pricing decision. That is the boundary the entire agent economy is now walking up to, and whoever crosses it first gets to rewrite what a company looks like. In this episode of Talking AI, Matt Paige sits down with Jay Hack, Head of AI at ClickUp and the founder of Codegen, one of the early autonomous coding-agent companies, which ClickUp acquired in late 2025. Jay spent years on the frontier of engineering automation and came away with a claim that sounds small and isn’t: a coding agent is just a general-purpose agent. The code was never the point. The loop was. The conversation covers why the best coding model tends to be the best model at everything, why the era of token maxing is ending and what a hard compute cap actually does to a team, how ClickUp turns a company’s docs, chats, and meetings into a context engine, why verification rather than generation is now the bottleneck on shipping, and what happens to an org chart when the scarcest resource on the team is high agency. In this episode, you’ll hear about: Why verifiability made software engineering the first domain AI genuinely transformed. Positive transfer, and why getting better at code makes a model better at everything else. What happened when Jay asked one model a question and it spawned 200 sub-agents to answer it. The coming compute-budget reckoning, and why a cap wouldn’t dent day-to-day productivity. A marketplace for ideas: allocating compute to people based on the quality of their pitch. Ultra coding, and the class of project that went from impossible to routine. The data silos problem, and why Jay sold Codegen to a company that already owned the context. Roll-ups, and using cheap models to distill signal so the expensive model never reads the noise. What ambient context does to onboarding, alignment, and the five-meetings-a-day habit. Hiring for high agency in an agent-first org. Why building ten features doesn’t mean shipping ten features. The zero-person company, and Jay’s timeline for it. --- Key Moments 00:01:30 — Why coding went first: verifiability, low stakes, and Stack Overflow 00:04:37 — “Build me Netflix”: level five self-driving for software engineering 00:07:02 — Positive transfer: why the best coding model is the best model at everything 00:10:08 — Fable spins up 200 sub-agents nobody asked for 00:11:00 — A marketplace for ideas: how compute gets allocated inside a company 00:13:43 — The a16z claim that humans are now cheaper than software 00:14:04 — The $10K-a-month token cap, and why productivity wouldn’t drop 00:15:00 — Ultra coding, and the projects that went from impossible to routine 00:17:17 — Context is everything: the data silos problem and why he sold Codegen 00:19:00 — Roll-ups: cheap models distilling signal so the expensive one skips the noise 00:22:00 — Why ClickUp, and the realization that a coding agent is just a general-purpose agent 00:24:01 — When context goes ambient: the org as a brain that finally sobers up 00:31:51 — Agent pilled: hiring for an era of valid chess moves 00:33:00 — High agency is the scarcest resource on your team 00:34:20 — Why any roadmap past three months is performative 00:36:06 — Ten features is not ten shipped features: verification is the bottleneck 00:37:56 — Does human in the loop still matter? The zero-person company

Legal is the department that can stop a business transaction cold. A contract goes into review and two weeks disappear. Procurement waits. Sales waits. And the tools that were supposed to fix that — an assistant bolted into Word, a chat window with a contract pasted into it — ask an in-house lawyer to trust a system that can give one answer today and a slightly different answer next week. In a field where the human carries the liability and the model does not, that is not a rounding error. That is the whole problem. In this episode of Talking AI, Matt Paige sits down with Emad Khazraee, co-founder and CTO of RiskVantage AI, previously VP of AI at Xometry, a data science and AI leader at Turing, an information science professor, and a fellow at Harvard’s Berkman Klein Center. For years Emad told his co-founder, Mark Afshar — a practicing lawyer turned in-house counsel for big pharma — that legal AI was a bad idea: a wrapper has no moat, and Anthropic or OpenAI will do it better than you overnight. What changed his mind was an architecture, not a market: a deterministic ontology that owns the legal reasoning, and small domain-specific language models that handle the language. The conversation covers why a nine-billion-parameter model running sub-second on a commodity GPU can match a frontier model inside a single domain, how subsidized token prices are distorting the entire legal AI market, why RiskVantage AI sells to procurement and sales ops rather than to lawyers who bill by the hour, what a failed PhD project on symbolic AI taught him about where determinism belongs, and whether the billable hour survives the decade. In this episode, you’ll hear about: What ChatGPT can’t know about your company: its risk appetite, its baselines, and the practices it expects every single time Why the legal services market — north of $900 billion, by Emad’s count — has every frontier lab gunning for it The objections that made him refuse to build a legal AI company, and the one that still holds Why a Word plugin stopped being defensible the moment Anthropic shipped its own How subsidized token pricing echoes Uber and Lyft, and who gets hurt when the subsidy ends The consistency problem: one answer today, a different answer next week, and a lawyer’s confidence gone Neuro-symbolic AI in plain English — a deterministic ontology for legal risk, LLMs for document understanding The three years Mark Afshar spent codifying legal risk before there was a product Why a 9B domain-adapted model is “dumb enough” that it can’t wander outside its sandbox Knowledge distillation, silver datasets, and self-distillation policy optimization in practice The sovereign-cloud niche: ITAR data, commodity GPUs, and customers whose data will never leave Outcome-based pricing, AI-enabled law firms, and what happens to the billable hour The access-to-justice case: pro se filings, public defenders, and what a $20 subscription changes

The best AI model in the world just scored 18.1%. On Zapier's own benchmark for real business work — the cross-app tasks any white-collar worker does every day — even the top frontier model completes them barely one time in five. That's the number Wade Foster keeps pointing at, and he runs an automation company that stands to gain from the hype. Instead, he makes the case for what actually works right now: not turning a model loose, but blending deterministic workflows with agents where each is strong. In this episode of Talking AI, Matt Paige sits down with Wade Foster, co-founder and CEO of Zapier, who built a scrappy Y Combinator startup into the $5 billion plumbing of the SaaS era on barely a million dollars raised. Foster called a company-wide “code red” the week GPT-4 launched, and he's spent the years since rewiring how Zapier — and its customers — actually use AI. The conversation covers why he shut the company down for a week in 2023, how AI habits actually stick, what Zapier's AutomationBench reveals about the gap between benchmark scores and real-world reliability, why coding models improve faster than knowledge-work models, how to tell a workflow from an agent, and the difference between individual AI and the institutional AI almost no company has cracked. In this episode, you'll hear about: The three things about GPT-4 that triggered Zapier's first-ever code red How daily AI use jumped from 11% to over 50% in a single hackathon week The moves that make AI habits stick: show-and-tell, repeat hackathons, and “not yet” Why the best model on AutomationBench still scores only 18.1% Why coding is easy to verify — and subjective knowledge work isn't The power of hybrid setups that blend deterministic workflows with agents Wade's prediction: most tokens on open-source models, most spend on the frontier What actually makes a good eval — hard for models, easy for humans, private data A plain-English definition of an “agent” versus a deterministic workflow The daily recap workflow Wade thinks everyone is sleeping on Floor raisers vs. ceiling raisers — and why individual AI isn't enough Why the six-month product roadmap is dead