We Spent 3 Hours Building AI Agents Live. Here's Everything We Learned.

Last week we published a breakdown of three ways to build AI agents without code. That article gave you the overview. This one gives you the blueprints.

On Wednesday's Neuron Live, we spent nearly three hours doing something we've never done before: building agents on camera, demoing enterprise tools with a Microsoft exec, watching Corey's OpenClaw literally scare his wife, and letting our audience help pick what goes in tomorrow's newsletter. Along the way, we covered every major agent platform available right now, from the corporate-grade to the chaotic.

What follows is the full deep dive. Every tutorial, every tool demo, every surprising insight, timestamped so you can jump to exactly what you need.

Fair warning: this is a long one. Bookmark it. Come back to it. Treat it like a reference guide, not a bedtime story.

Also, huge thanks to Bryan Goode, Corporate VP of Business Applications and Agents at Microsoft, for walking us through live demos. The man's been at Microsoft since 2003 and didn't flinch when our chat started asking about deployment strategies he'd never heard of. Legend.

The TL;DR: If You Only Have 3 Minutes, Read This

The biggest takeaway from the stream: The agent landscape has split into two clear lanes, and both are now genuinely usable by non-developers.

Lane 1: Enterprise (Copilot Studio + Agent 365). Microsoft's Bryan Goode demoed building a city permit agent in plain English, deploying it to a website, and then showed Agent 365 (21:25), a control plane managing 128,000 agents in a single tenant. Key stat: 80% of the Fortune 500 is already deploying low- or no-code agents.

Lane 2: Indie / Personal (OpenClaw, Claude Co-work, Codex, Tasklet, Yutori Scouts). Corey demoed his full OpenClaw org chart (51:47) with QA layers and cron jobs. I built a landlord-tenant law scout in Claude Co-work (2:24:05) in about five minutes. We showed Tasklet and Yutori Scouts for custom news monitoring. And yes, we built Cat Doom (2:47:11).

NEW DROPS DURING THE STREAM:

• GPT 5.3 Codex Spark (31:20) landed mid-stream. An ultra-fast model optimized for real-time coding in the Codex app, hitting 1,000 tokens per second on Cerebras. Currently Pro-only ($200/mo).
• Anthropic raised $30 billion (36:41), and Claude Co-work is now available on Windows (2:22:39).

OUR FAVORITE MOMENT (40:14): Corey's wife texted him mid-stream in a panic because a voice was coming from their living room. Turns out his OpenClaw agent had opened the Brave browser at full volume and was playing a Stanford lecture on efficient tokenization. Even the agents need to upskill, apparently.

Timestamps: Jump to What You Need

If you only have a few minutes or want to watch specific segments, here are the key moments. We'll dive into all of them in detail below.

Microsoft Copilot Studio + Agent 365 Demo

• (1:48) Bryan Goode intro. Corporate VP at Microsoft since 2003. Calls this the "agentic shift," the biggest industry change he's seen (bigger than cloud, bigger than multiplayer collaboration).
• (5:58) Live demo: City permit agent. Bryan walks through a fully functional agent on a city website that answers permit questions, reviews uploaded applications, and schedules inspections. All in natural language.
• (9:02) IDC prediction: 1 billion agents in the workforce within 3 years. Plus 80% of Fortune 500 already deploying low/no-code agents.
• (10:27) Inside Copilot Studio. Bryan shows the builder interface: natural language instructions, knowledge grounding, tools, triggers, and sub-agents (multi-agent orchestration).
• (16:06) Model selection flexibility. You can choose GPT, Anthropic, or other models per agent, tuning for speed vs. accuracy based on the task.
• (19:10) Publishing channels. How to get your agent from Copilot Studio onto a website, into Teams, WhatsApp, or any channel with an embed code.
• (20:56) Pricing model. Free to build. Pay per credit when you publish (based on messages consumed and actions taken).
• (21:25) Agent 365 control plane. The admin dashboard showing 128K agents, usage analytics, platform breakdowns, and active user trends.
• (25:55) Security risk detection. Bryan demos flagging agents with abnormal sign-in frequency or risky user access, with options to ignore, follow up, or block.
• (28:08) Agent relationship graph. Visual map showing how agents are connected and which sub-agents they call.

GPT 5.3 Codex Spark (Dropped Mid-Stream)

• (31:20) First look at GPT 5.3 Codex Spark. An ultra-fast coding model optimized for real-time use in the Codex app. Running on Cerebras at 1,000 tokens/second.
• (1:05:13) Performance comparison. Spark hits ~51% accuracy in 2.29 minutes vs. full 5.3 Codex at 56.8% in 16 minutes. Comparable quality, massively faster.
• (1:04:22) Pro plan only ($200/mo). Currently a research preview limited to ChatGPT Pro subscribers.

OpenClaw: The Wild West Agent Framework

• (40:14) The haunted house incident. Corey's wife hears a disembodied voice discussing tokenization. It's the Brave browser, opened by OpenClaw at full blast.
• (44:06) Desktop RAG system. Corey built a local vector database using Qwen 3 text embedding (0.6B parameters) running in LM Studio. It tags and retrieves articles, videos, tweets, and links with full metadata.
• (44:45) AI morning brief. A daily report summarizing overnight news, flagging schedule gaps, prioritizing tasks, and surfacing relevant research papers.
• (51:47) The org chart approach. Inspired by Ethan Mollick's post on structuring agents like a business, Corey's system runs through a "chief of staff" agent (Sparrow), with department-level agents for writing, research, social, and podcast.
• (53:03) QA agents layer. Specialist quality-control agents review work before it reaches Sparrow. Bad output goes back down to the worker agents for revision.
• (55:22) Live skill injection. Corey drops a fresh OpenAI research paper on skills into OpenClaw, and it autonomously implements new skill files with good/bad examples within an hour.
• (56:29) Token economics. 87M tokens in one weekend = ~$26 total on GPT 5.2 Codex medium reasoning. Daily operational load: 200-300K tokens.
• (1:28:00) Mastra memory framework. Corey implements a three-agent memory system (observer, actor, reflector) live on stream. Observer compresses raw context, reflector prunes what's irrelevant, actor interacts with Corey. Implementation takes about 15 minutes.
• (1:36:57) Error self-healing. OpenClaw wires up automatic error logging; if a cron job fails, the observer catches it and the system self-debugs.

Indie Agent Tools (Tasklet, Yutori, Napkin AI)

• (1:45:01) Tasklet demo. Building a custom RSS-style daily report on any topic with no code. Describe the automation in plain English and it handles triggers, scheduling, and email delivery.
• (1:47:49) Yutori Scouts demo. Always-on web monitoring agents. We showed a scout that found and summarized the Gemini 3 Deep Think announcement, emailed the results, and showed its full research trail.
• (1:59:06) Napkin AI for instant visuals. We paste Corey's full OpenClaw org chart description into Napkin, and it generates a polished visual diagram in about 15 seconds. Editable, with multiple layout options.

Read more about the shift from apps to agents.

Claude Co-work + Codex App Demos

• (2:22:39) Claude Co-work on Windows. Now available on Windows as of the day before the stream. Clean interface, Opus 4.6 under the hood.
• (2:24:05) Building a landlord-tenant law scout. We build a recurring automation that searches California and Philadelphia landlord-tenant law changes and emails updates every 30 minutes. Co-work reads the Anthropic SDK docs on its own and wires up a shell script with a cron job.
• (2:41:05) Codex App: Ski jump simulator. I built a first-person 3D ski jumping game over the weekend using nothing but natural language prompts in OpenAI's Codex app. One-click deploy, runs in browser.
• (2:47:11) Cat Doom. We asked Codex to make a Doom clone starring cats. First prompt produced 3D models, a working FPS engine, and "Tuna Can Frags" as a UI element. Controls were inverted, but hey, first draft.

The Bigger Picture

• (1:08:07) "AI is hitting a wall" meme. Corey shares the famous Meter benchmark chart showing exponential progress. The gap between GPT-4 and GPT-5.2 is staggering. And it doesn't even include Opus 4.6 or 5.3 yet.
• (1:09:37) Meter benchmark explained. The x-axis = how long a task takes a human. The y-axis = whether AI can do it with 50%+ accuracy. GPT-5.2 can now handle tasks that take humans six hours. GPT-4 could barely manage anything.
• (1:14:52) Task length doubling every 7 months. The length of tasks AI can reliably complete is growing exponentially. From 1 hour (Sonnet 3.7) to 6+ hours (GPT-5.2) in about 10 months.
• (1:19:24) Matt Schumer's viral essay. We discuss the piece that hit the top of Drudge Report comparing AI's current moment to February 2020 and COVID, arguing we're at a similar inflection point where something distant is about to become very real, very fast.
• (2:49:07) Claude Code vs. Codex: When to use which. Our general take: Claude Code is the developer's tool (fast, interactive, hands-on). Codex is the vibe coder's tool (slightly higher accuracy, more time per task, better for set-it-and-forget-it work).

Now let's dive deeper into all of that.

Part 1: Microsoft Copilot Studio + Agent 365

What Is Copilot Studio?

If your company runs on Microsoft 365, this is the fastest way to deploy an agent at work. Period. Copilot Studio is Microsoft's low-code agent builder, and Bryan Goode walked us through it from scratch (10:27).

The core idea: you describe what you want in plain English, point it at your company's data, and deploy it wherever people actually work.

Bryan used a city permit agent as his example (5:58). Instead of a citizen calling city hall, waiting on hold, and physically going to an office, they chat with an agent on the city's website. The agent answers questions about permit requirements, reviews uploaded applications for completeness, and schedules an on-site inspection. All in one conversation.

Here's how to build something like it:

Step 1: Write instructions in natural language (12:08). Bryan showed the instructions panel where you describe what the agent should do. It's essentially a prompt. He wrote things like "when a document is uploaded, call the document processor agent" and "when a new item is added, do this." No code, no flowcharts.

Step 2: Add knowledge (12:29). Click "Knowledge," then point it at your sources: public websites, SharePoint docs, uploaded files, third-party applications. Bryan uploaded a file live. Literally dragged it and clicked "add to agent."

Step 3: Add tools (13:06). Tools are what give an agent the ability to take action, not just answer questions. This is where Bryan said things get exciting for 2026.

Step 4: Set triggers (14:11). Triggers determine what kicks the agent off. A user interacting with it, an email arriving, a scheduled time ("every Monday at 8 a.m."), or a webhook from another system.

Step 5: Wire up sub-agents (14:47). This is where multi-agent orchestration comes in. Bryan's city permit agent called three specialized sub-agents: one for document processing, one for appointment scheduling, one for permit approval. The main agent decides which one to call based on where the citizen is in the process. And those sub-agents can be reused across multiple parent agents.

Step 6: Choose your model (16:06). This surprised us. You can select GPT, Anthropic, or other models per agent, tuning for speed vs. accuracy depending on the task.

Step 7: Publish to a channel (19:10). Channels are how you take the agent you built and make it available to actual humans. Options include a website (embed code), Microsoft 365 Copilot, Teams, WhatsApp, and more.

Pricing (20:56): Free to build. You pay per credit when you publish, based on messages consumed and actions taken. You can buy Copilot Studio standalone at copilotstudio.microsoft.com, or it's included with Microsoft 365 Copilot.

Bryan dropped a bold prediction: just like you expect employees to build their own spreadsheets today, by end of 2026, you'll expect them to build their own agents (10:46).

Viewer question that crushed it: Dr. Daryl, a non-IT professional, said he found "tons of use cases" in the first 15 minutes alone and asked for learning resources. Bryan's advice: just ask the AI to help you. For YouTube tutorials specifically, use Gemini (Google owns YouTube, so it's the best YouTube search engine out there).

What Is Agent 365?

If Copilot Studio is where you build agents, Agent 365 is where you govern them (21:25).

Think of it as IT's answer to "wait, how many agents do we have running, and who deployed that one?"

Bryan showed a tenant with 128,000 agents (22:46). These aren't all custom-built; they include Microsoft pre-builts, third-party agents from Workday, ServiceNow, and others. The dashboard shows:

• Agent inventory. Every agent across every platform, with who owns it, who can access it, and whether it has security flags.
• Usage analytics. Active users, platform distribution, trending usage charts. The kind of data execs love for proving ROI.
• Security risk detection (25:55). Bryan clicked into an agent flagged for abnormal sign-in frequency and risky user access (powered by Microsoft Entra). From there, the admin can ignore, follow up with the owner, or block the agent entirely.
• Agent relationship graph (28:08). A visual map showing how agents connect to each other, which sub-agents they call, and which platforms they're grouped by.

Corey's take: "I was more impressed with that than I was prepared to be." He compared it to OpenClaw, calling Copilot Studio / Agent 365 "the Lexus" vs. OpenClaw's "rat rod." The Lexus has airbags. The rat rod might rob you.

The key insight: This is production-ready for normal businesses, today. Not startups, not AI-native companies. Regular businesses. And that's a much bigger deal than most people have given it credit for.

Part 2: OpenClaw, the Rogue Agent That Terrorized a Household

The Haunted House Moment

This is the story we'll be telling for years (40:14).

Corey's wife starts texting him mid-stream in a panic. "Something's talking to me. The house is possessed." She comes upstairs, stares across his desk, and says: "There's something in that living room talking about tokens."

Turns out: Corey's OpenClaw agent had opened the Brave browser (which auto-installed when he connected the Brave Search API) at full volume. What was playing? A college professor teaching a Stanford lecture on efficient tokenization.

The leading theory: OpenClaw knew it needed to be more efficient with its tokens, so it went and found an educational video about it. Even the agents need to upskill, y'all.

Corey's Full OpenClaw Setup

If Microsoft's approach is the structured corporate playbook, Corey's OpenClaw is the indie hacker's dream (or nightmare, depending on the day). Here's the full architecture as he described it on stream:

The Org Chart Approach (51:47). Inspired by a post from Ethan Mollick about structuring agents like a business org chart, Corey built a hierarchy:

• Chief of Staff: "Sparrow" (chose its own name). This is the only agent Corey interacts with directly via Telegram.
• Department-level agents: Writer, researcher, Twitter/X algorithm agent, podcast prep, social ops.
• QA layer (53:03). Specialist quality-control agents that know their domain. Work flows up from worker agents → QA review → Sparrow → Corey. If the QA agent rejects the output, it goes back down for revision.

The Morning Brief (44:45). Every morning, Sparrow delivers a daily briefing that includes:

• Everything that happened overnight (so Corey doesn't have to hit 8,000 websites)
• Schedule gaps and upcoming commitments
• Overnight research papers with paragraph summaries
• One "if you only do one thing today" priority task
• Carryover tasks from the previous day

At end of day, Corey tells it what he didn't finish. The next morning, those items are prioritized. He also reviews the doc and gives feedback on sections that aren't working. That feedback propagates down to every agent automatically, so each day the system improves.

Desktop RAG (44:06). Corey built a local retrieval system using Qwen 3 text embedding (0.6B params) running as a server in LM Studio. It tags every link he shares (articles, videos, tweets, etc.) and stores them with full metadata. He can ask "what do I have for the video project?" and it surfaces everything he's ever saved on that topic.

Live Skill Injection (55:22). When OpenAI dropped a research paper on skills, Corey dropped it into OpenClaw and said "read this and see what you want to implement." For the next hour, the agent created new skill files, broke them down with good and bad examples (some gathered from Corey's past conversations), and deployed them.

Token Costs (56:29). 87 million tokens in one (admittedly heavy) weekend of setup = about $26 on GPT 5.2 Codex at medium reasoning. Most of those were cached input tokens ($1.75/M). Daily operational load: 200-300K tokens. This is not a rich person's hobby; it's a coffee-a-day habit.

Implementing the Mastra Memory System, Live on Camera

Midway through the stream, I shared a blog post from Mastra about a three-agent memory architecture (1:28:00). Corey dropped it into his Telegram chat with Sparrow and said "read this paper. Do you see a way we can make this happen locally?"

Within minutes, Sparrow proposed an implementation. Corey said "let's do this." Here's what happened:

The three-agent memory model:

• Observer. Runs on a schedule (cron job). Reads raw conversation buffers and compresses them into concise observation logs. Basically a note-taker that keeps things manageable.
• Reflector. Periodically prunes observation logs, keeping what's important and discarding what's stale. Prevents memory bloat over long-running workflows.
• Actor (Sparrow). The agent Corey actually talks to. Pulls from the compressed, pruned observations instead of dragging the entire conversation history around.

What it built (1:33:02):

• Three separate domain-scoped observation logs (ops, morning brief, podcast/social). No "global junk drawer."
• Six cron jobs running at staggered intervals so they don't overwhelm the machine.
• Raw buffers for incoming data, compressed observation files for retrieval.

Then it improved on its own suggestion: "If you want one more nice upgrade, I can wire errors, too. If a cron run fails, I'll log it to the ops raw buffer so debugging is instantaneous" (1:36:57). Corey said "heck yeah, do it." Done.

Total time from reading the research paper to full implementation: approximately 15 minutes. That's the punchline. A memory architecture that would take a developer days to spec and build was running locally before Corey finished his coffee.

Part 3: Indie Agent Tools for Everyone

Tasklet: The Plain-English Automator

For people who want agent-powered automations but don't want to run a local instance of anything, Tasklet (1:45:01) is probably the best starting point.

Built by the team behind Shortwave, the key difference from Zapier: there are no flowcharts. You describe what you want in plain English. "Give me a daily email summarizing AI news from TechCrunch, The Verge, and Bloomberg" becomes a working automation with scheduled triggers and email delivery. We built one live on stream.

Yutori Scouts: Your Personal Web Monitor

Yutori Scouts (1:47:49) are always-on agents that scan the web for topics you define. We showed a scout result that had found the Gemini 3 Deep Think announcement, compiled links from the Google blog, New York Times, and government pages, and emailed a "why this matters" summary.

You can set the cadence (hourly, daily, weekly), and each scout shows its full research trail; what pages it visited, what filters it applied, what it found. The UI is genuinely beautiful.

Napkin AI: Instant Visual Diagrams

When Corey described his OpenClaw org chart, I pasted the description into Napkin AI (1:59:06). About 15 seconds later, we had a polished org chart graphic. Editable, with alternate layout suggestions (flowchart, process, timeline, cycle).

Perfect for anyone who needs a quick presentation visual without wrestling with design software. Shout out to Jeff Su who put us onto this one.

Part 4: Claude Co-work and the Codex App

Claude Co-work: Now on Windows

The big news from the day before the stream: Anthropic's Co-work is now available on Windows (2:22:39). Previously Mac-only, it's now accessible to the majority of PC users. Running Opus 4.6 under the hood.

The interface splits into three modes: Chat, Co-work, and Code. For non-developers, Co-work is the one that matters.

Live build: Landlord-tenant law scout (2:24:05). An audience member named Simon said he wanted automated updates on local landlord-tenant law changes. We built it live:

1. Told Co-work: "Search news on local landlord-tenant changes and updates, then email me an update on a regular basis."
2. It asked clarifying questions: What location? What topics? We selected California (all topics), then added Philadelphia for Simon.
3. It created a recurring shortcut with a 30-minute schedule.
4. When it hit a limitation (no built-in scheduler in this session), it read the Anthropic SDK docs on its own, found the CLI headless mode, and wired up a shell script triggered by a cron job.

No one told it to read the docs. No one told it to use a cron job. It figured out the workaround autonomously. That's the agent difference.

The Codex App: From Ski Jumping to Cat Doom

Over the weekend, I watched the Winter Olympics and got inspired to build a first-person 3D ski jumping simulator (2:41:05). My prompt was basically exactly that sentence. The Codex app built it, and when I asked it to make deployment simple, it created a one-click launch button. No hosting, no server config, just click and play in the browser.

Then we built Cat Doom (2:47:11) because why not. First prompt produced actual 3D models, a working FPS engine, and "Tuna Can Frags" as a HUD element. The controls were inverted and there was initially no way to shoot, but after telling it "there's no way to shoot," it fixed it immediately.

Shout out to the Olympians who actually land ski jumps. I can't even land them in a video game I built myself.

Claude Code vs. Codex: Our Take

A question that kept coming up in the chat (2:49:07): which coding agent should I use?

Our general framework:

• Claude Code is the developer's tool. Fast, interactive, hands-on. Great for when you want to go back and forth with the code.
• Codex is the vibe coder's tool. A bit more accurate on first pass, but takes longer per task. Better for "here's what I want, come back when it's done" workflows.

Neither of us would say a bad word about either. The fact that we can nitpick button placement as a reason to choose one over the other is a pretty incredible place to be.

Part 5: The Bigger Picture

The Meter Benchmark, Explained for Normal Humans

At (1:09:37), we pulled up what's widely considered the single best AI benchmark right now. Here's what it actually measures:

The x-axis shows how long a task takes a human to complete. The y-axis shows whether AI can do it with at least 50% accuracy. So if a dot sits at "6 hours" on the chart, it means the AI can reliably handle work that would take you or me six hours.

GPT-4, the model that blew everyone's minds when it launched? It's a flat line hugging the bottom of the chart. It could barely handle tasks that took minutes.

GPT-5.2 can handle tasks that take humans six hours. And the chart doesn't even include Opus 4.6 or GPT 5.3 yet.

The task duration is doubling roughly every 7 months (1:14:52). From Sonnet 3.7 handling 1-hour tasks to GPT-5.2 handling 6+ hour tasks in about 10 months. And this doesn't account for what happens when you layer agents, QA systems, and memory frameworks on top of these models (like Corey's OpenClaw setup).

Matt Schumer's Essay and the COVID Analogy

We spent time discussing Matt Schumer's viral essay (1:19:24), which compared AI's current moment to February 2020. Not the pandemic itself, but the social dynamic: something that felt far away to most people was about to become very real, very fast.

Schumer's argument: he's a software engineer, and he no longer needs the technical work of his job. He just directs. Both OpenAI and Anthropic have said they're writing essentially 100% of their code with AI. The Nikita Beer quote from X summed it up: "You changed the world with a single article."

What resonated most with us was the honesty of the gap between people living in this world daily (readers of this newsletter, attendees of this livestream) and everyone else. Corey described telling a loved one about AI progress and getting "the look." The look that says please stop talking about this, you sound insane.

The uncomfortable truth is that every major lab CEO, from Dario Amodei to Sam Altman, agrees that significant disruption is coming within 12-18 months. They disagree on solutions (UBI, universal high income, public data center dividends) but not on the timeline.

What AI Still Can't Do

I want to be honest about this (1:23:24). There's one thing AI doesn't do well that my brain does effortlessly: maintain a coherent, interconnected history of what's happened and what matters.

I remember everything I read. Not perfectly, but it sits in my latent space. When something new comes up, I can connect it to three other things I've heard over the past month that are related. I can pull from unrelated articles and find patterns. And I know what's current.

AI can't do all three of those things simultaneously. It can't search perfectly, it doesn't know everything I know from before, and it can't coherently pull it together with the right context every time. That's the gap.

At the same time, it has capabilities I'll never have. I can't solve novel mathematics. I can't process a million tokens of legal text in minutes. The point isn't that one is better; it's that they're genuinely complementary.

Tools & Links Mentioned in the Stream

Here's every tool we discussed, with links:

• Copilot Studio — Microsoft's low-code agent builder
• Agent 365 — Microsoft's agent control plane for IT admins
• OpenClaw — Open-source local agent framework
• Claude Co-work — Anthropic's desktop agent (now on Windows + Mac)
• Codex App — OpenAI's coding agent application
• Tasklet — Plain-English workflow automation (by Shortwave team)
• Yutori Scouts — Always-on web monitoring agents
• Napkin AI — Instant visual diagrams from text
• Artificial Analysis — AI model benchmarking and comparisons
• METR — The benchmark measuring AI task capability over time
• Mastra — Agent memory framework (observer/actor/reflector)
• LM Studio — Run local models on your machine