Alex Ratner co-founded Snorkel AI out of Chris Ré's Stanford lab and helped establish data-centric AI as a field. Today, Snorkel is a $1.3B company shipping thousands of data sets and environments a week to frontier labs and vertical AI teams like Harvey.

In this conversation, he argues our ability to build AI agents has outpaced our ability to measure them. That gap is what's keeping most enterprise agents stuck in demo purgatory.

If you can't measure it, you can't improve it. And you can't deploy it.

In this conversation:

• The three axes of the evaluation gap: input complexity, autonomy horizon, and output complexity
• Big Law Bench: how Snorkel and Harvey benchmarked legal agents on deep-research tasks that take lawyers 10-15 hours
• What Snorkel's $3M Open Benchmarks Grant is funding, and why "benchmaxxing" critiques don't kill the case for public benchmarks
• Why 40-50% of Snorkel's data work is still review and labeling, even with the best models in the loop
• The "expert-agentic" era, where domain expertise (law, finance, coding, even woodworking) is the new bottleneck
• Why self-supervision is a dead end outside narrow cases like distillation
• The false dichotomy between data and environments, and why pure-environment vendors miss how AI actually works

Chapters

(00:00) Intro: Alex Ratner and Snorkel AI
 (02:50) What the evaluation gap actually is
 (06:05) Moravec's paradox and the jagged frontier
 (08:46) Where AI agents fall down in enterprise work
 (10:40) Big Law Bench: benchmarking Harvey's legal agents
 (12:00) The three axes: input, autonomy horizon, output
 (18:31) Snorkel's $3M Open Benchmarks Grant
 (22:33) From "janitorial" to epicenter: 15 years of data-centric AI
 (29:26) The expert-agentic data era
 (34:54) The false dichotomy between data and environments
 (40:05) DoorDash Tasks and expert data at scale

Connect with Alex Ratner:

• X/Twitter: https://x.com/ajratner
• Snorkel AI: https://snorkel.ai

Connect with Conor:

• Newsletter: https://newsletter.chainofthought.show/
• Twitter/X: https://x.com/ConorBronsdon
• LinkedIn: https://www.linkedin.com/in/conorbronsdon/
• YouTube: https://www.youtube.com/@ConorBronsdon

More episodes: https://chainofthought.show

Thanks to Galileo — download their free 165-page guide to mastering multi-agent systems at galileo.ai/mastering-multi-agent-systems

What happens when a VP of AI Software at a major chip company goes all-in on AI coding agents for his own team's work?

Anush Elangovan runs 10–12 Claude Code agents across three machines, burns 6.5 billion tokens a week, and rewrote a 25-year-old project (Slurm → Spur in Rust) in a single night.

He does it all on dangerously-skip-permissions.

About Anush
Anush Elangovan is Corporate VP of AI Software at AMD. He founded Nod.ai, where his team built SHARK and was a primary contributor to Torch-MLIR and IREE. AMD acquired Nod.ai in 2023, and Anush now leads AI software strategy across AMD's full silicon portfolio. Before Nod.ai, he shipped the graphics stack on the first ARM Chromebook and led Chrome OS's migration to Gentoo.

We cover:

• How Anush runs 10–12 parallel agents with a geo-distributed AMD hardware rig
• Why the test harness is the new code review (and why agents are "sneaky and dumb")
• Rewriting a 25-year-old project in Rust overnight, without opening the editor
• Why every new project is in Rust specifically because he refuses to learn it
• The "HR partner fixing engineering bugs" moment and what it says about upskilling
• Why normal SDLC is dead and speed is the only durable moat
• AMD's fully open-source software stack and how community contributions are accelerating ROCm
• "Software is just tokens" and what that means for AMD's bet against CUDA lock-in

Connect with Anush
LinkedIn: linkedin.com/in/anushelangovan
Twitter/X: @AnushElangovan
AMD AI blog: amd.com
AMD AI Developer Program: amd.com/developer

Connect with Conor
Newsletter: newsletter.chainofthought.show
Twitter/X: @ConorBronsdon
LinkedIn: linkedin.com/in/conorbronsdon
YouTube: @ConorBronsdon

More episodes: chainofthought.show

Chapters
0:00 Cold open
0:21 Welcome + guest intro
3:43 250K lines a week, 10–12 parallel agents
7:34 Agent architecture + geo-distributed test rig
9:57 When does AI-generated code become a liability?
14:12 80% tests first: the test harness philosophy
18:24 Dangerously-skip-permissions + testing as code review
19:52 "Normal SDLC is dead in the agentic world"
20:44 Advice for engineers and leaders who feel behind
24:51 Tokens, throughput, and what happens next
26:29 Block layoffs, uneven AI gains, the 25-year Slurm rewrite
32:55 Galileo sponsor break
34:24 When agents go off the rails: sneaky and dumb
37:52 Orchestrator agents vs. focused multi-threading
40:45 Open source, ROCm, AMD's software bet
44:19 "Software is just tokens"
45:24 AMD Developer Program + community contributions
47:09 Where to start with AMD
48:39 Heterogeneous compute
50:13 Outro

Thanks to Galileo. Download their free 165-page guide to mastering multi-agent systems at galileo.ai/mastering-multi-agent-systems

Full show notes: newsletter.chainofthought.show

Disclaimer from our host: All views, opinions and statements expressed on this account are solely my own and are made in my personal capacity. They do not reflect, and should not be construed as reflecting, the views, positions, or policies of my employer. This account is not affiliated with, authorized by, or endorsed by my employer in any way.

Sudhir Hasbe is President and Chief Product Officer at Neo4j, the graph database company powering 84 of the Fortune 100 (Walmart, Uber, Airbus) at $200M+ ARR and a $2B+ valuation. Before Neo4j, he ran product for all of Google Cloud's data analytics services: BigQuery, Looker, Dataflow, and led the Looker acquisition.

His thesis: the hallucinations we blame on AI models are really a data architecture problem. LLMs weren't trained on your enterprise knowledge, so handing them a data lake with 10,000 disconnected tables and asking them to reason is the wrong design. The fix is knowledge graphs: feeding the model a structured map of relationships, entities, and context so it can reason over meaning, not just vector similarity.

Sudhir breaks down the five capabilities knowledge graphs unlock for enterprise AI: GraphRAG (moving accuracy from 60% to 97%), semantic mapping across siloed systems, context graphs, agent memory, and multi-hop reasoning. He explains three architecture patterns customers are actually shipping, why giving an LLM hundreds of tools makes it worse, and what Uber, EA Sports, Klarna, and Novo Nordisk are doing differently.

This is the case for treating knowledge as infrastructure.

We cover:

• Why enterprise AI needs a different playbook than consumer AI
• The five data asset types every agentic system needs: system of record, historical, memory, context, and reference
• How GraphRAG combines vector search and graph traversal to move from 60% accuracy to 95%+
• Three architecture patterns: semantic layer only, semantic map plus domain data, full consolidation (the Klarna/Kiki model)
• What context graphs capture that Salesforce doesn't: the Slack and email negotiation behind every deal
• Why giving an LLM hundreds of tools drops accuracy, and how Uber uses knowledge graphs as a business validation layer
• What Neo4j's Aura Agent, MCP server, and A2A support mean for developers starting today

Chapters:

(0:00) Why building a self-driving car is hard
(0:22) Intro
(2:03) Hallucinations as a data architecture problem
(4:31) From models-as-core to systems-of-knowledge
(6:13) Why data lakes fail AI agents
(9:15) The five data asset types enterprise agents need
(11:46) Where basic RAG breaks down: the Spotify metadata lesson
(16:00) GraphRAG: 3x accuracy, easier development, explainability
(18:47) Semantic mapping across the enterprise estate
(19:23) Three knowledge-graph architecture patterns
(22:42) Context graphs: capturing the "why" behind decisions
(25:33) Individual vs. organizational agent memory
(28:40) Multi-hop reasoning for fraud rings and AML
(31:52) Why there are no shortcuts in enterprise AI
(36:38) What happens when you give an LLM 100 tools
(39:19) The Uber example: knowledge graph as business validation
(44:42) First mile of a 26-mile marathon
(48:32) Aura Agent, MCP server, and the A2A protocol
(50:43) Where developers should start

Connect with Sudhir Hasbe:

• LinkedIn: https://www.linkedin.com/in/shasbe/
• Neo4j: https://neo4j.com/
• Neo4j Aura: https://neo4j.com/product/auradb/

Connect with Conor:

• Newsletter: https://newsletter.chainofthought.show/
• Twitter/X: https://x.com/ConorBronsdon
• LinkedIn: https://www.linkedin.com/in/conorbronsdon/
• YouTube: https://www.youtube.com/@ConorBronsdon

More episodes: https://chainofthought.show

Thanks to Galileo — download their free 165-page guide to mastering multi-agent systems at: 
galileo.ai/mastering-multi-agent-systems

Every few weeks at Microsoft, someone would build an AI prototype that blew everyone's minds. Three months later? Dead. "We can never ship that." Dan Klein watched this happen for five years before he decided to do something about it.

Dan is co-founder and CTO of Scaled Cognition, a professor of computer science at UC Berkeley, and winner of the ACM Grace Murray Hopper Award. His previous startups include adap.tv (acquired by AOL for $405M) and Semantic Machines (acquired by Microsoft in 2018), where he spent five years integrating conversational AI. His PhD students now run AI teams at Google, Stanford, MIT, and OpenAI.

At Scaled Cognition, Dan's team built APT1 (the Agentic Pre-trained Transformer) for under $11 million. It's a model designed for actions, not tokens, with structural guarantees that go beyond prompt-and-pray.

Dan makes the case that current LLMs are plausibility engines, not truth engines, and that the gap between demo and production is where most AI projects die.

• Why prompting is a fundamentally unreliable control surface for production AI
• How APT1's architecture gives actions and information first-class status instead of treating everything as tokens
• The specific failure modes that kill enterprise AI prototypes within three months
• Why stacking multiple models to check each other produces correlated errors, not reliability
• How Scaled Cognition applied RL to conversational AI when there's no zero-sum winner
• Why every S-curve in AI gets mistaken for an exponential — and what comes after the current plateau
• The societal risk of systems that produce output indistinguishable from truth

Chapters
(0:00) Cold open: RL is about doubling down on what works
(0:28) Introducing Dan Klein and Scaled Cognition
(2:53) The demo-to-production gap: why AI prototypes die
(5:40) Why prompting is not a real control surface
(8:06) Modular decomposition vs. end-to-end optimization
(10:55) Are LLMs fundamentally mismatched with how we use them?
(14:26) What's wrong with benchmarks today
(20:27) APT1: building a model for actions, not tokens
(24:14) What makes data truly agentic
(28:02) Hallucinations as an iceberg — visible vs. undetectable
(34:16) Building a prototype model for under $11 million
(39:57) Applying RL to conversations without a zero-sum winner
(43:31) LLMs as a condensation of the web — and what happens when it runs out
(50:07) Reasoning models: where they work and where they don't
(53:04) Early deployments in regulated industries
(57:14) Why multi-model checking fails
(1:00:34) The minimum bar for trustworthy agentic systems
(1:04:07) Societal risk: when AI output is indistinguishable from truth
(1:13:33) Where Dan is inspired in AI research today

Connect with Dan Klein:

• Scaled Cognition: https://scaledcognition.com
• LinkedIn: https://www.linkedin.com/in/dan-klein/
• UC Berkeley NLP Group: https://nlp.cs.berkeley.edu

Connect with Conor:

• Newsletter: https://newsletter.chainofthought.show/
• Twitter/X: https://x.com/ConorBronsdon
• LinkedIn: https://www.linkedin.com/in/conorbronsdon/
• YouTube: https://www.youtube.com/@ConorBronsdon

More episodes: https://chainofthought.show

Thanks to Galileo — download their free 165-page guide to mastering multi-agent systems at galileo.ai/mastering-multi-agent-systems

Richmond Alake is Director of AI Developer Experience at Oracle and one of the most concrete voices on agent memory right now. His AI Engineer World's Fair talk on architecting agent memory crossed 100,000 views, he built the open-source MemoRIS library, and he co-created a course with Andrew Ng.

In this conversation, Richmond walks through memory engineering as a distinct discipline from prompt engineering and context engineering, demos a memory-aware financial services agent that runs vector, graph, spatial, and relational search in a single query, and explains the principle that separates production-grade memory systems from prototypes: don't delete, forget. If you're building agents that need to remember anything across sessions, this is the episode.

We cover:
- Why memory engineering deserves its own name, separate from prompt and context engineering
- The two failure modes Richmond sees most: wrong mental model and deleting instead of forgetting
- Four human memory types mapped to agent architecture: working, episodic, semantic, and procedural
- Demo: AFSA, a memory-aware financial services agent with converged search across data types
- How the Generative Agents paper's decay formula (relevance + recency + importance) enables controlled forgetting
- Where context engineering ends and memory engineering begins 
- Why files work for prototypes but databases win in production

Chapters:
(0:00) Memory is the last battleground in AI
(0:28) Meet Richmond Alake, Oracle's AI DevEx lead
(2:23) Why memory engineering is its own discipline
(7:57) The failure modes nobody talks about
(12:49) Demo: a memory-aware financial services agent
(18:30) Segmenting context windows by memory type
(19:22) Four human memory types mapped to agent architecture
(23:51) Procedural memory in production systems
(27:11) Don't delete, forget: implementing controlled decay (33:32) Sponsor: Galileo
(35:46) Where context engineering ends and memory engineering begins
(38:50) Is agent memory fundamentally a database problem?
(44:13) Files vs. databases: what production actually needs
(51:09) Picking your lane in the AI noise
(55:44) Richmond's courses with Andrew Ng, O'Reilly classes, and where to follow

Connect with Richmond Alake: LinkedIn: https://www.linkedin.com/in/richmondalake/
Check out his Youtube: https://www.youtube.com/@richmond_a
O'Reilly courses: https://www.oreilly.com/live-events/ai-memory-management-in-agentic-systems/0642572179274/
Diagrams from the episode: https://imgur.com/a/mMtcAtk

Connect with Conor:
Newsletter: https://newsletter.chainofthought.show/
Twitter/X: https://x.com/ConorBronsdon
LinkedIn: https://www.linkedin.com/in/conorbronsdon/
YouTube: https://www.youtube.com/@ConorBronsdon

More episodes: https://chainofthought.show

Thanks to Galileo — download their free 165-page guide to mastering multi-agent systems at http://www.galileo.ai/mastering-multi-agent-systems

Michel Tricot co-founded Airbyte, the open source data integration platform with 600+ free connectors that hit a $1.5 billion valuation. Now he's building the company's next product: an agent engine, currently in public beta. His thesis is that agents don't fail because models are bad. They fail because the data feeding them is wrong: context poisoning is killing them.

Michel demos this live. A simple Gong query through raw API calls burned 30,000 extra tokens and took three minutes. The same query through Airbyte's context store ran in one minute and used a fraction of the context window. Conor and Michel dig into why RAG alone won't cut it, what a "context engineer" actually does, how Airbyte tracks entities across Salesforce, Zendesk, and Gong without embeddings, and whether the SaaS apocalypse playing out in public markets is overblown.

Chapters:

0:00 Intro
0:20 Meet Michel Tricot, CEO of Airbyte
2:27 Data Got Us to the Information Age. Context Gets Us to Intelligence.
4:48 How Context Poisoning Breaks Agents
7:49 Why Airbyte Customers Stopped Loading Into Warehouses
10:12 Live Demo: Context Store vs Raw API Calls
10:38 What Does a Context Engineer Actually Do?
14:14 RAG Isn't Dead, But How We Build It Will Die
16:41 30K Wasted Tokens Without Proper Context
22:22 Cross-System Joins: Zendesk, Gong, and Salesforce
26:12 The Open Source Agent Connector SDK
29:45 The SaaS Apocalypse Is Overblown
36:09 From Data Pipes to Agent Infrastructure
38:51 What Agents Need to Get Right by Summer
40:48 Memory Is Just Another Form of Context
43:07 Outro

About the Guest:

Michel Tricot is the CEO and co-founder of Airbyte, the open source data integration platform used by thousands of companies to move data between systems. Before Airbyte, he led data ingestion and distribution engineering at LiveRamp. Airbyte raised at a $1.5 billion valuation and offers 600+ free connectors. The company recently launched the public beta of its agent engine, which includes a context store, agent connector SDK, and MCP integration.

Guest Links:

• Airbyte
• Michel on LinkedIn
• Agent Blueprint (Substack)
• Agent Connector SDK (GitHub)

Show Links:

• Chain of Thought Podcast
• Newsletter
• Conor on LinkedIn
• Conor on X/Twitter

Thanks to our presenting sponsor Galileo. Download their free 165-page guide to mastering multi-agent systems at galileo.ai.

Yujian Tang started the r/AI_Agents subreddit in April 2023. For the first year, it barely moved. Then it hit 9,000 members, he went on vacation, came back to 36,000, and now it's approaching 300,000. In this episode, Yujian talks about how that community grew alongside his event business (Seattle Startup Summit, 900+ attendees last year), his two failed startups, and why he just filed paperwork to launch his own venture fund.

Conor and Yujian dig into the mechanics of starting a fund from scratch (Delaware PO boxes, EIN numbers, lawyers), why AI startup valuations have doubled in the last two years, whether a one-person unicorn is realistic, and what failed founders learn that successful ones sometimes miss.

Chapters:

(0:00) Cold Open: The Subreddit Growth Explosion

(0:21) Intro and Meet Yujian Tang

(1:06) From AI Research to Community Building

(7:26) Where AI Applications Are Headed

(10:03) The AI Bubble and a Valuation Reset

(10:39) Getting Deal Flow Through Community Events

(14:02) Filing the Fund: The Boring Side of VC

(16:04) How r/AI_Agents Went from Crickets to 300K

(18:39) Building an Accidental Empire

(26:37) What Two Failed Startups Taught Him

(29:52) Why Pre-Seed Valuations Are Out of Control

(37:37) The One-Person Unicorn Debate

(39:50) Seattle Startup Summit 2026

(42:17) What Chain of Thought Should Cover Next

(43:25) Outro

About the Guest:

Yujian Tang is the founder of Seattle Startup Summit, the largest startup event in the Pacific Northwest. He created the r/AI_Agents subreddit (now nearly 300K members), runs hackathons and developer events across Seattle and the Bay Area, and is launching an early-stage AI venture fund.

Guest Links:

Seattle Startup Summit: seattlestartupsummit.com

Reddit: reddit.com/r/AI_Agents

Show Links:

Chain of Thought Podcast: https://chainofthought.show

Newsletter: https://newsletter.chainofthought.show/LinkedIn: https://www.linkedin.com/in/conorbronsdon/X/Twitter: https://x.com/ConorBronsdon

Sponsor: Thanks to Galileo. Download their free 165-page guide to mastering multi-agent systems at galileo.ai/mastering-multi-agent-systems

Sterling Chin stopped thinking of AI as a tool and started treating it like a junior employee. Onboarded it with context, corrected its mistakes, and gave it writing rules.

Forty days later, MARVIN was handling 90% of his workday.

In this episode of Chain of Thought, Sterling (Applied AI Engineer and Senior Developer Advocate at Postman) walks through live demos of MARVIN, his personal AI assistant built on Claude Code. From pulling meeting transcripts and updating Jira tickets to drafting blog posts and managing his calendar, MARVIN runs as a full-time AI chief of staff.

We cover:

• How MARVIN bookends Sterling's workday from first login to the end of the day
• Personality, sub-agents, and writing rules that make MARVIN an effective co-worker
• Automating meeting notes to Jira tickets
• Why DIY assistants outperform big tech alternatives
• How Sterling onboarded 12+ colleagues at Postman, including non-technical knowledge workers
• What the compute crunch means for open source AI

Connect with Sterling:

• LinkedIn: https://www.linkedin.com/in/sterlingchin/
• Twitter/X: https://x.com/SilverJaw82
• MARVIN Template: https://github.com/SterlingChin/marvin-template

Connect with Conor:

• Newsletter:⁠ ⁠https://conorbronsdon.substack.com/
• Twitter/X:⁠ https://x.com/ConorBronsdon⁠
• LinkedIn:⁠ https://www.linkedin.com/in/conorbronsdon
• YouTube:⁠⁠ https://www.youtube.com/@ConorBronsdon⁠⁠

🔗 More episodes:⁠⁠ https://chainofthought.show⁠⁠

Timestamps:

(0:00) Intro

(0:28) Meet Sterling Chin and the MARVIN AI Assistant

(9:10) Live Demo: How MARVIN Bookends Your Workday

(16:04) Personality, Sub-Agents, and Writing Rules

(22:00) Automating Meeting Notes to Jira Tickets

(29:30) Why DIY AI Assistants Outperform Big Tech

(40:55) Treat Your AI Like a Junior Employee

(46:41) How to Get Started with MARVIN

(55:36) The Compute Crunch and Open Source Future

Thanks to Galileo — download their free 165-page guide to mastering multi-agent systems at galileo.ai/mastering-multi-agent-systems

Intercom was spending $250K/month on a single summarization task using GPT. Then they replaced it with a fine-tuned 14B parameter Qwen model and saved almost all of it. In this episode, Intercom's Chief AI Officer, Fergal Reid, walks through exactly how they made that call, where their approach has changed over time, and how all of their efforts built their Fin customer service agent.

Fergal breaks down how Fin went from 30% to nearly 70% resolution rate and why most of those gains came from surrounding systems (custom re-rankers, retrieval models, query canonicalization), not the core frontier LLM. He explains why higher latency counterintuitively increases resolution rates, how they built a custom re-ranker that outperformed Cohere using ModernBERT, and why he believes vertically integrated AI products will win in the long term.

If you're deciding between fine-tuning open-weight models and using frontier APIs in production, you won't find a more detailed decision process walkthrough.

🔗 Connect with Fergal: 

• Twitter/X: https://x.com/fergal_reid

• LinkedIn: https://www.linkedin.com/in/fergalreid/

• Fin: https://fin.ai/

🔗 Connect with Conor:

• YouTube: https://www.youtube.com/@ConorBronsdon

• Newsletter: https://conorbronsdon.substack.com/

• Twitter/X: https://x.com/ConorBronsdon

• LinkedIn: https://www.linkedin.com/in/conorbronsdon/

🔗 More episodes: https://chainofthought.showCHAPTERS

0:00 Intro

0:46 Why Intercom Completely Reversed Their Fine-Tuning Position

8:00 The $250K/Month Summarization Task (Query Canonicalization)

11:25 Training Infrastructure: H200s, LoRA to Full SFT, and GRPO

14:09 Why Qwen Models Specifically Work for Production

18:03 Goodhart's Law: When Benchmarks Lie

19:47 A/B Testing AI in Production: Soft vs. Hard Resolutions

25:09 The Latency Paradox: Why Slower Responses Get More Resolutions

26:33 Why Per-Customer Prompt Branching Is Technical Debt

28:51 Sponsor: Galileo

29:36 Hiring Scientists, Not Just Engineers

32:15 Context Engineering: Intercom's Full RAG Pipeline

35:35 Customer Agent, Voice, and What's Next for Fin

39:30 Vertical Integration: Can App Companies Outrun the Labs?

47:45 When Engineers Laughed at Claude Code

52:23 Closing Thoughts

TAGSFergal Reid, Intercom, Fin AI agent, open-weight models, Qwen models, fine-tuning LLMs, post-training, RAG pipeline, customer service AI, GRPO reinforcement learning, A/B testing AI, Claude Code, vertical AI integration, inference cost optimization, context engineering, AI agents, ModernBERT reranker, scaling AI teams, Conor Bronsdon, Chain of Thought

How do you deploy AI agents to 12,000 employees in just 8 weeks? How do you do it safely? Angie Jones, VP of Engineering for AI Tools and Enablement at Block, joins the show to share exactly how her team pulled it off.

Block (the company behind Square and Cash App) became an early adopter of Model Context Protocol (MCP) and built Goose, their open-source AI agent that's now a reference implementation for the Agentic AI Foundation. Angie shares the challenges they faced, the security guardrails they built, and why letting employees choose their own models was critical to adoption.

We also dive into vibe coding (including Angie's experience watching Jack Dorsey vibe code a feature in 2 hours), how non-engineers are building their own tools, and what MCP unlocks when you connect multiple systems together.

Chapters:

00:00 Introduction

02:02 How Block deployed AI agents to 12,000 employees

05:04 Challenges with MCP adoption and security at scale

07:10 Why Block supports multiple AI models (Claude, GPT, Gemini)

08:40 Open source models and local LLM usage

09:58 Measuring velocity gains across the organization

10:49 Vibe coding: Benefits, risks & Jack Dorsey's 2-hour feature build

13:46 Block's contributions to the MCP protocol

14:38 MCP in action: Incident management + GitHub workflow demo

15:52 Addressing MCP criticism and security concerns

18:41 The Agentic AI Foundation announcement (Block, Anthropic, OpenAI, Google, Microsoft)

21:46 AI democratization: Non-engineers building MCP servers

24:11 How to get started with MCP and prompting tips

25:42 Security guardrails for enterprise AI deployment

29:25 Tool annotations and human-in-the-loop controls

30:22 OAuth and authentication in Goose

32:11 Use cases: Engineering, data analysis, fraud detection

35:22 Goose in Slack: Bug detection and PR creation in 5 minutes

38:05 Goose vs Claude Code: Open source, model-agnostic philosophy

38:17 Live Demo: Council of Minds MCP server (9-persona debate)

45:52 What's next for Goose: IDE support, ACP, and the $100K contributor grant

47:57 Where to get started with Goose

Connect with Angie on LinkedIn: https://www.linkedin.com/in/angiejones/

Angie's Website: https://angiejones.tech/

Follow Angie on X: https://x.com/techgirl1908

Goose GitHub: https://github.com/block/goose

Connect with Conor on LinkedIn: https://www.linkedin.com/in/conorbronsdon/

Follow Conor on X: https://x.com/conorbronsdon

Modular: https://www.modular.com/

Presented By: Galileo AI

Download Galileo's Mastering Multi-Agent Systems for free here: https://galileo.ai/mastering-multi-agent-systems

Topics Covered:

- How Block deployed Goose to all 12,000 employees

- Building enterprise security guardrails for AI agents

- Model Context Protocol (MCP) deep dive

- Vibe coding benefits and risks

- The Agentic AI Foundation (Block, Anthropic, OpenAI, Google, Microsoft, AWS)

- MCP sampling and the Council of Minds demo

- OAuth authentication for MCP servers

- Goose vs Claude Code and other AI coding tools

- Non-engineers building AI tools

- Fraud detection with AI agents

- Goose in Slack for real-time bug fixing