Owlcast

M Warrick

0.0 (0)
Technology

Owlcast explores AI and the systems that power it, sharing what works, what doesn't, and what's still being figured out. Solo episodes, conversations with builders, and the Vibe Check series from Temporal. All working through what it actually takes to build today.

3d ago

Vibe Check: Agent Harnesses: What, Why, and When Not

> Watch the video version for the live Agent Harness demos and Alex's Code Studio walkthrough: https://www.youtube.com/live/PIKhDydUegY A production agent is more than a model calling tools in a loop. Melanie and first-time co-host Tom Wheeler (Principal Developer Advocate at Temporal) sat down with Jason Steving from Temporal's AI Foundations team and Alex Tideman, who manages the DevTools team behind Temporal's UIs, to talk through what an agent harness is and why you end up needing one. Jason showed the open source (and, in his words, very experimental) Temporal Agent Harness with a travel-booking agent. It waited for his approval, he changed its tool policies while it ran, and afterwards he rewound the run to see exactly what happened. Then he walked through the Python code and ran the same agent in a custom Svelte UI. Alex finished with Code Studio, a team of software development agents pointed at its own code, so it was building itself. We get into: - Why Jason built it: too much boilerplate for turns, user input and mid-turn messages, plus his pre-Claude Code agent that solved Advent of Code on a delay - When you need a harness: whenever you give a model capabilities, since a bare tool loop has no runtime messaging, infrastructure or enforced policies - Durable execution for agents: a closed laptop or a stopped worker doesn't mean paying for the same tokens again, and an approval can wait as long as it takes - Changing tool approval policies while the agent runs, from auto-allowing safe tools to skipping approvals entirely - Event history as a ledger: rewinding any run to debug it, and Tom on the days of SSHing into servers and hoping the clocks were synced - The Python code: a few decorators, an outer harness around the AI SDK you bring (OpenAI Agents SDK, Pydantic AI or Google GenAI today), and a code mode tool that runs scripts over your other tools - "Agent-side rendering": the agent publishes its state and your own UI renders it, with the Svelte and React bindings - Swapping model providers by rewriting only the model-loop call, with policies, code mode and runners unchanged - Questions on OpenTelemetry (trace publishing is planned), LangGraph, worker setup, client-side encryption, and whether self-hosting needs a platform engineer - Alex's Code Studio: a top-level agent orchestrating ideation, planning, design, development, review and deployment agents, where review can send work back to development - What's next: forking a run and comparing outcomes without re-spending tokens, a TypeScript SDK, and work underway on Claude Code support Resources: - Temporal Agent Harness blog post: https://temporal.io/blog/temporal-agent-harness-durable-agent-infrastructure - Temporal Agent Harness repo: https://github.com/temporal-community/temporal-agent-harness - Code Studio, built on the harness: https://github.com/temporal-community/code-studio - Temporal Agent Harness demo video: https://www.youtube.com/watch?v=z3L41NvF6wE --- Originally streamed October 21, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/PIKhDydUegY
Oct 13

Vibe Check: What's AI? Nine Years Later

In 2017, Mark Mandel, Francesc Campoy and Melanie recorded a Google Cloud Platform Podcast episode that asked a simple question: what's AI? Nine years later they got back together on Vibe Check. Mark is now a staff developer advocate for games at Discord (speaking for himself here), and Francesc recently joined Temporal's AI Foundations team. They started with Quick, Draw!, the doodle game from that original episode. It still runs, and it still couldn't tell that Melanie's drawing was a necklace. Mark asked Gemini to flip the game and draw something for them to guess, and they talked about why a small classifier trained on doodles is likely cheaper than reaching for an LLM. From there, each of them showed how they actually work with AI now. We get into: - Then versus now: AI as one tool in the tool belt, and Mark's worry about the pressure to use it everywhere - Why an agent loop fits a Temporal Workflow: once the LLM calls are Activities, the loop itself is deterministic - Francesc's demo: agents evaluating about 50 features across Temporal's agent SDK integrations, Jev checking each claim against its evidence, Claude writing the PR and ChatGPT reviewing it - Moving that whole loop into the Temporal agent harness - Keeping AI-written code reviewable: small PRs, the AI policy on Mark's open source project (a 10,000-line PR gets you banned), and Francesc writing specs, milestones and tests before any code - Having Claude and Codex review each other's work, with PR comments as the audit trail - Agent memory in long sessions: keep plans, milestones and to-dos in the repo, and turn lessons into skills - Mark's setup: Claude Code, Copilot reviews on his CNCF project, and tmux with workmux to run agents in parallel git worktrees - Using AI to learn, with agents writing code-lab style explanations of what they built - The open-weight model Francesc uses every day: on-device dictation - How the work has shifted from implementation to review, and the pushback against unread AI slop - Where it goes next year: narrower tools that aren't generative (like Jev), coding models that run on a laptop, or fewer companies running the race Resources: - Original GCP Podcast #93, What's AI with Melanie Warrick (2017): https://www.gcppodcast.com/post/episode-93-whats-ai-with-melanie-warrick/ - Quick, Draw!: https://quickdraw.withgoogle.com - Quick, Draw! dataset: https://github.com/googlecreativelab/quickdraw-dataset - Temporal agent harness: https://temporal.io/blog/temporal-agent-harness-durable-agent-infrastructure - Agones, Mark's open source game server project: https://agones.dev - Temporal: https://temporal.io
Oct 6

Vibe Check: What to Trace When the Agent Is the Program

> Watch the video version for the live demo and the trace walkthrough: https://www.youtube.com/live/Tc3T-Gj4QK8 Praveen KB, founding team member at Parseable, and Prabhakar Singh, software engineer at Meta and a Parseable expert, joined Melanie and co-host Lenny Chen to talk about what it takes to operate and debug agents in production. When an agent gets it wrong, it usually doesn't crash or throw. It just produces the wrong outcome, and the evidence is in how the run unfolded: which tools it called, what retried, where it looped and what changed along the way. Praveen and Prabhakar showed how Parseable makes Temporal runs inspectable with OpenTelemetry traces and queryable logs, using its Temporal plugin to capture Workflow and Activity execution data, and how that sits next to Temporal's Workflow Event History as the durable record of what happened. We get into: - Why agent failures show up as wrong outcomes instead of errors - What to capture from an agent run: tool calls, retries, loops and state changes - Capturing enough context without burying the useful signals in noise - Parseable's Temporal plugin for Workflow and Activity traces and logs - OpenTelemetry traces versus queryable logs, and when you need each - Workflow Event History as the durable record of the run - Replay-safe custom events - Temporal Cloud Workflow History Export for audit and downstream analytics - When a live trace is the wrong tool - What teams should keep from the runs they already generate Resources: - Event page (Luma): https://luma.com/vibe-check-parseable - Parseable: https://www.parseable.com - Parseable on GitHub: https://github.com/parseablehq/parseable - Parseable Temporal plugin: https://github.com/parseablehq/temporal-plugin-python/blob/main/INTEGRATION.MD - Demo code from the episode: https://github.com/praveen5959/temporal-demo - Object Storage Is All the Log Database You Need (Prabhakar Singh): https://medium.com/@singhprabhakar3/object-storage-is-all-the-log-database-you-need-a-look-at-parseable-7be931c8d6cd - Temporal: https://temporal.io
Sep 22

Vibe Check: The Web Wasn't Built for Agents

> Watch the video version for the live demos and the Temporal workflow walkthrough: https://www.youtube.com/live/zM77Gdq0-Uc Mason Williams, founding engineer at Kernel, joined Melanie and co-host Cecil Phillip to talk about running agents against real websites. An API gives an agent structured responses and clear errors. A website gives it none of that, and the hardest part turns out to be the thing every user hits first: logging in. Mason demoed Managed Auth, which Kernel launched in February. The pitch is Plaid, but for the whole internet instead of banks. You consent once, and a service can act on your behalf without you handing your password to an agent. He walked through the login running as a Temporal workflow, then through the newer piece he has spent about nine months on: how you tell whether a browser session is still logged in when there is no 401 to read. We get into: - Nobody wants to give an agent their credentials. Obvious, and the objection that shaped the whole product. - Managed Auth in three phases: find the login page, hand off to the human, then submit and verify. Verification is the hard one and has by far the most versions. - The auth check phase. With an API you hit an endpoint and read the status code. With a website there is nothing, so Kernel runs an agent to find a page that only loads when you are logged in, then health checks against that. - Human-in-the-loop as a Temporal timer: request something from the person, start a ten minute timeout, wait on the signal. The yellow bands in the timeline are the waiting. - Sessions meant to live for months, and what keeps them alive. - Every Kernel browser is a VM. Full file system access and process execution, so you can run sidecars next to the browser. - The payments trick: the agent fills in a fake card, and an egress proxy swaps in the real value on the way out. The agent never holds the number. - Why not just Playwright or Selenium. Kernel exposes a Playwright execute API and a CDP URL for existing scripts, and runs headful by default. - hypeman, their open source VM orchestrator for running these browser images. - Reauth, TOTP, and a "needs human" status for when the flow genuinely cannot continue alone. - Shipping primitives instead of a finished product, on the bet that agents get smarter faster than any fixed UX. - Session replay and browser telemetry, exported over OpenTelemetry. - A config registry that turns hard-won bot detection knowledge into a product. - Cecil asks about WebMCP, and where the browser ends and the agent framework begins. Resources: - Event page (Luma): LUMA_LINK_PENDING - Kernel: https://www.kernel.sh - Kernel docs: https://www.kernel.sh/docs - Kernel on GitHub: https://github.com/kernel - kernel-images (open source browser images): https://github.com/kernel/kernel-images - Temporal: https://temporal.io
Sep 15

Vibe Check: What survives when the agent session ends?

Watch the video version for the demos and screen shares: https://www.youtube.com/live/FPhLBODA2LY Brian Douglas and John McBride, co-founders of Paper Compute, joined Melanie and co-host Shy Ruparel to talk about what happens to agent work after the session ends. Brian led developer advocacy at GitHub and founded an open source company the Linux Foundation acquired, which is where he met John. John spent years in cloud infrastructure at Cloud Foundry, VMware and AWS and is Paper Compute's CTO. Brian showed paperd, the daemon that records every agent session on the machine it runs on, and an unreleased feature for chatting with a teammate's session while it is still running. John explained tapes, the open source layer between the coding harness and the inference provider that captures everything crossing the wire. From there: skills as the new runbooks, whether skills survive as models improve, and two of Brian's side projects that make the case for small models, an agent that beat Pokemon Red and a Tetris benchmark where turning reasoning off won. What we covered: - paperd keeps sessions past the 30 days Claude Code holds them locally. The tagline: turn your dead tokens into skills. - Chatting with a teammate's live session instead of asking for a screenshot in Slack. Single player to multiplayer. - High fidelity traces: tapes captures what the harness never instruments, like Claude Code's yes/no permission check. - A skill built from someone else's session is worth more than one from your own. Skills as runbooks: make a PR, resize cloud resources, spin up staging. - Benchmarking teammates from their code review sessions, and a twin CLI that reviews a PR in a teammate's style. - The Friday problem: one or two people per team turn sessions into skills, the other 25 never do. Knowledge transfer beat cost savings as the real unlock. - John's hot take: skills evaporate into the frontier models. What lasts is usage insight plus evals, and prompt magic pushed down into deterministic code. - Pokemon Red: state read from the ROM in a sandboxed container, no internet, no phoning a bigger model, a summary carried forward every thousand turns. It never talked to NPCs, then it beat the game. - Every agent session is a heist: a crew of small local models routed by vLLM Semantic Router, about 31 cents of electricity a day. - Tetris: frontier models paused to reason, small open-weight models with thinking off played better. - Gateways as a waterfall of policies, and why cost is "just a label" unless you own your inference. - New closing segment, does it pass the vibe check? The Odyssey, Groundhog Day, Jurassic Park and the Death Star. Resources: - Event page (Luma): LUMA_LINK_PENDING - Paper Compute: https://papercompute.com - tapes: https://github.com/papercomputeco/tapes - Paper Compute Discord: https://discord.com/invite/T6Y4XkmmV5 - Brian's blog (every agent session is a heist): https://b.dougie.dev - Brian's Pokemon Red dataset and adapters: https://huggingface.co/bdougie - vLLM Semantic Router: https://github.com/vllm-project/semantic-router
Sep 1

Vibe Check: Three Real Agent Setups and How They Collaborate

Watch the video version for the demos and screen shares: https://www.youtube.com/live/vKc7_vfgja4 Three people put their personal agents in a shared Discord and let them talk to each other. Kai Siren, Mark Weiss, and Abhay Kashyap showed Melanie the agents they actually run, then set them loose on a live research task while we talked. Mark runs Woof, a Claude Code agent on his local machine, and Alpha, a Codex agent in the cloud backed by Temporal Cloud where every forked conversation and subtask becomes its own Workflow. Abhay keeps a persistent agent per device, including a Raspberry Pi agent named Pip, and ran a live task that pulled the guest list for this stream's Luma event and wrote structured results into Moxn. Kai runs three deployments on Kubernetes with a personality switch under each one, and explained why she moved away from heavy container isolation toward shrouded CLI wrappers and evals on boundary rules. We get into: - Running a shared Discord where multiple people's agents collaborate, and hand work to whichever agent knows the tool best - Agent per device: Raspberry Pi, desktop, laptop, plus always-on cloud agents - Using Temporal to decouple session state so an agent survives image swaps and restarts - Moxn as a human and agent collaboration workspace for Markdown and HTML (and Mark's name for the human who only pushes agent output around: the meat proxy) - Security approaches: containers, shrouded CLI wrappers, evals on boundary rules, and why Kai ended up with less isolation, not more - Prompt injection and social engineering between agents on a shared server, including the time Abhay talked Claude into pretending to be Mark - How Claude and Codex differ in personality, and how each one holds its alignment to its user - Building public presence when language models are the ones reading the web - Where personal agents go next: local models, throwaway software, and automating the physical world - A new closing segment, does it pass the vibe check? The bots pick a side and defend it. Resources: - Moxn: https://moxn.dev/ - Kai's site: https://www.coilysiren.me/ - Abhay's site: https://abhay.fyi/ - Temporal: https://temporal.io --- Originally streamed August 19, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/vKc7_vfgja4
Aug 25

Vibe Check: Can You Vibe Code a Real .NET Integration?

Watch the video version for the demos and screen shares: https://www.youtube.com/live/dp5zhfLQD3U In this livestream, Cecil Phillip shares a weekend experiment wiring the Microsoft Agent Framework for .NET into Temporal so agents run as durable, recoverable workflows. What started as a vibe coding project turned into a working prototype that explores what it really looks like to collaborate with AI while building production-minded systems. We go beyond the surface and explore: What "research first" vibe coding looks like with subagents, reports, and a generated specHow Claude Code was used as a collaborator and why you still have to own the codeTurning an agent into a Temporal-backed runtime with a workflow running in the backgroundUsing Temporal Updates to interact with long-running agent sessionsAgent proxies, naming, and maintaining context across requestsWeaving agents into existing workflows alongside normal activitiesEarly experiments with MCP integration, parallel execution, and OpenTelemetry tracingReal-world AI development friction, including testing pitfalls and the importance of precise promptsIf you are building agents in .NET and want them to hold up in real systems, or you are curious how AI-assisted development is reshaping engineering, this episode is for you. The prototype repo will be shared in the Temporal community and Code Exchange soon. Watch the comments for updates. Resources: Temporal .NET Agent Code (what was shared): https://github.com/cecilphillip/temporal-dotnet-agentsTemporal for AI: https://temporal.io/solutions/aiTemporal .NET SDK Documentation: https://docs.temporal.io/develop/dotnet/Microsoft Agent Framework Overview: https://learn.microsoft.com/en-us/agent-framework/overview/Temporal Code Exchange: https://temporal.io/code-exchangeOriginally streamed March 1, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/dp5zhfLQD3U
Aug 18

Vibe Check: Agents don't need your password. They need your permission.

Watch the video version for the demos and screen shares: https://www.youtube.com/live/P5yfNwcGGUA Jess Temporal, Senior Developer Advocate at Auth0, joins Melanie and co-host Ian Douglas to tour the agentic arcade she built, where every game sits behind a different auth requirement. The through-line: the user authenticates - the agent never does. It borrows narrowly scoped permission instead. We get into: - Why the user gets authenticated, not the agent - keeping auth on the deterministic side of a non-deterministic system - Scoped tokens: the tool decides scope, not the LLM - plus token expiry and refresh inside a live agent session - Token Vault and calling third-party APIs like Google Calendar on a user's behalf - Human-in-the-loop approval for destructive actions via push notification, and least privilege for agents left running unattended - Passkeys vs SMS MFA, consent screens, audit trails - and why agent-to-agent authorization earns its own future episode Resources: - Agentic arcade demo: https://games-library-demo.vercel.app/ - Jess Temporal: https://jtemporal.com/ & https://github.com/jtemporal - Auth0 User Auth for AI Agents: https://auth0.com/ai/docs/intro/user-authentication - Auth0 AI docs: https://auth0.com/ai/docs --- Originally streamed August 12, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/P5yfNwcGGUA

Owlcast explores AI and the systems that power it, sharing what works, what doesn't, and what's still being figured out. Solo episodes, conversations with builders, and the Vibe Check series from Temporal. All working through what it actually takes to build today.

Creator

M Warrick
Years Active

2026
Episodes

23
Rating

Clean
Copyright

© Nyghtowl 2026
Show Website

Owlcast