Owlcast | Podcast in RSS.com

Owlcast

di M Warrick

Come fare Tecnologia

Stagione 1

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

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

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

Vibe Check: What should an agent remember?

> Watch the video version for the demos and screen shares: https://www.youtube.com/watch?v=VvaVzu_BjS0 What should an agent remember, and where should that memory actually live? Melanie sat down with Chris Gambill (Gambill Data) and Scott Haines (Databricks) to get concrete about agent memory: what belongs in the context window, what belongs in memory files, and what needs to live outside the agent entirely. Chris demoed OmniGent, the open source meta-harness from Databricks that runs multiple coding agents side by side. We watched it stand up a World Bank data pipeline into a medallion architecture, including a debate step where two models argue the approach before one goes and builds the plan. Scott walked through how he keeps sessions lean using a memory.md that points to the real source of truth instead of reloading the whole codebase, and why his context window stayed around 32k tokens instead of ballooning into the millions. From there we got into the parts that actually matter in production: - The three levels of memory: session, team or workspace, and organization-wide - Why hard security rules like "nothing gets pushed to main without a PR" belong outside the memory file, as an actual hook and not a suggestion - The idea the guests called "dreaming": agents summarizing their own sessions so the next one starts from the lessons, not the raw token history - Token usage as a signal: why token leaderboards are a bad productivity metric and what real ROI looks like (PRs opened and closed, healthier communities, actual contributions) - Multi-project and external memory: Postgres-backed sessions, sharing state through GitHub, and the risk of stale memory polluting a good result - Where autonomous agents and real money should still stop and ask first Resources - OmniGent (open source meta-harness from Databricks): https://omnigent.ai/ - Databricks: https://www.databricks.com/ - Chris Gambill, Gambill Data: https://gambilldata.com/ - Chris Gambill on YouTube (data engineering): https://www.youtube.com/@GambillDataEngineering - Scott Haines on YouTube (Conferences playlist): https://www.youtube.com/playlist?list=PLBJeAtDBQjJMANOGMxUd30nSIhdw9bcNt - Temporal orchestration for Open Lakehouse: https://www.openlakehouse.io/technologies/orchestration - Temporal, durable orchestration for AI agents: https://temporal.io --- Originally streamed July 22, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/watch?v=VvaVzu_BjS0

Vibe Check: How autonomous is the agentic GTM stack?

Watch the video version for the demos and screen shares: https://www.youtube.com/live/kT9xu6xEurI Nehal Agrawal, a go-to-market engineer at Invigilo, joined us to show how she builds her own agents for GTM. Off-the-shelf tools like Clay and Apollo were too fragmented for Invigilo's niche verticals in construction, oil and gas, and manufacturing, so she built a custom orchestrator instead, and it pulled a 60% reply rate on post-event warm outreach over a typical 20%. Topics covered: - Why fragmented tools did not fit niche verticals, and when it makes sense to build your own orchestrator - The post-event outbound workflow: lead list in, agent-drafted sequences out, and a reply rate that mostly landed after the third follow-up - Why the agent drafts into Outlook but never sends on its own, and where human-in-the-loop belongs (cold versus warm, deal value) - The harnesses and dedicated security agent she runs to keep agents from running amok or burning tokens - Build versus buy for the GTM stack, agent-to-agent communication, and a recap of AI Engineer World's Fair including its first GTM track Resources: - Invigilo: https://www.invigilo.ai/ - Nehal Agrawal: https://www.nehalag.com/ - AI Engineer (AIE): https://www.ai.engineer/

Vibe Check: Sandboxing, Skills, and Surviving Dev to Prod

> Watch the video version for the demos and screen shares: https://www.youtube.com/live/CMXCnbbiPoY Episode description Melanie and co-host Cecil Phillip are joined by James Bayer, CPO at Flox and a longtime infrastructure engineer from Pivotal and HashiCorp. James walks through reproducible software environments built on the Nix ecosystem — running the same Temporal environment directly on macOS, inside a Docker dev container, and inside an Apple Container microVM — then makes the case for treating AI skills like real software you lifecycle-manage. In this episode: Reproducible environments with Flox, separating software packaging from isolation Running one environment three ways: bare macOS, a Docker dev container, and an Apple Container microVM The manifest.toml and default environments for keeping utilities consistent everywhere, plus team sharing via hub.flox.dev Treating AI skills as software (roughly 25% ship with vulnerabilities), and registering the Temporal skill with Claude to build a live workflow Secrets patterns with Keychain, 1Password, and Vault, package and skill firewalls, and cross-platform portability across x64, ARM64, and Windows via WSL2 Resources: Flox: https://flox.dev Flox in Five (5-min tutorial): https://flox.dev/docs Flox Hub: https://hub.flox.dev Flox on GitHub: https://github.com/flox Temporal Validated Patterns: https://temporal.io/resources/validated-patterns

Vibe Check: There's No Agent Without the Harness

Watch the video version for the demos and screen shares: https://www.youtube.com/live/N8Z-XIs_m8k Episode description Melanie is joined by Elizabeth Fuentes Leone (AI Engineer & Developer Advocate at AWS) and co-host Shubham Londhe to make the case that there's no agent without the harness: the code and infrastructure around the model that turns it into something you can run in production. Elizabeth builds a harness from scratch with AWS Bedrock AgentCore in a single CLI command, then walks through the pieces that do the work and where durability fits in. In this episode: What a harness actually is: the agent loop plus the infrastructure that feeds the model and handles its output Bedrock vs. AgentCore, and swapping model providers (Bedrock, Anthropic, OpenAI, Gemini) by changing one model ID AgentCore's built-ins: an MCP tool gateway with semantic search, session and persistent user memory, and zero-config observability Where Temporal fits (durable execution, retries, and state as a tool inside the loop) and why it complements, not replaces, LangGraph or LlamaIndex If you've built an agent that runs fine on your laptop and fell apart in production, this one's for you. Resources: Bedrock AgentCore: https://aws.amazon.com/bedrock/agentcore/ AgentCore credits: https://events.elifuentes.tech/events/agentcore-harness/ Elizabeth Fuentes Leone: https://elifuentes.tech/ Shubham Londhe: https://www.trainwithshubham.com/ Temporal on GitHub: https://github.com/temporalio How Temporal uses Bedrock AgentCore: https://aws.amazon.com/blogs/apn/how-temporal-uses-amazon-bedrock-agentcore-to-create-robust-ai-systems/

Vibe Check: Priority, Fairness & Building Workflows from Scratch

Watch the video version for the demos and screen shares: https://www.youtube.com/live/-nuLcSKS1cI Melanie was joined by Xinyi Chen, a software engineer on Temporal's Cloud Growth team, and co-host Melissa McGregor from Temporal's docs team and author of the priority and fairness docs. Xinyi built priority and fairness into Temporal workflows from scratch, using a pizza shop with a single chef to make the concepts concrete before moving into live coding. Topics covered: Rate limiting, priority, and fairness as task queue features, explained with a pizza shop analogy Building the workflow from scratch live in an IDE with Claude and the Temporal Skill loaded Running the logic as a standalone activity Starting workflows and activities directly from the Temporal Cloud UI Workflow streams, now in public preview for Python with TypeScript coming soon Resources: Task queue priority and fairness docs: https://docs.temporal.io/develop/task-queue-priority-fairness Temporal AI cookbook: https://docs.temporal.io/ai-cookbook Temporal on GitHub: https://github.com/temporalio Databricks Data + AI Summit: https://www.databricks.com/dataaisummit Originally streamed June 11, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/-nuLcSKS1cI

Vibe Check: Zero to Data Pipeline — Building with AI & dlt in 10 Minutes

Watch the video version for the demos and screen shares: https://www.youtube.com/live/GMsIhP3RIHgElvis Kaharu (Developer Advocate at dltHub) joined Melanie and co-host Cecil Phillip for a Vibe Check on building data pipelines in 10 minutes with dlt, the open source Python SDK for moving data from anywhere it lives. Elvis walked through how dlt fits between custom Python scripts and managed platforms, and showed how an agent can one-shot a pipeline when the SDK gives it strongly typed, declarative primitives to fill in. Topics covered: Why data pipelines are more than copying from point A to point B (schema normalization, incremental loads, schema evolution as a SEV) Scaffolding a project with uvx dlthub start and what gets generated for Claude (skills, roles, starter pipeline) Installing dlt toolkits for REST APIs, data quality, and file systems One-shotting a GitHub issues pipeline with Claude and the REST API skill Switching destinations with a single line of code (DuckDB, Snowflake, Iceberg, S3, Hugging Face) Schema contracts with Pydantic and the gatekeeper pattern for handling bad rows Attaching to a pipeline with Marimo notebooks to inspect data, schemas, and run data quality checks Failure introspection via checks.get_failures() and feeding failed rows into another dlt pipeline Exporting dlt transformations as dbt models for regulated industries (health, finance) Where Ibis fits in (Python expressions that compile to SQL in Snowflake) Snowflake Cortex AI operators through Ibis as a way to shift left on AI workloads Skills vs. MCP in the dlt setup, and how skills get tuned differently for Claude, Codex, and Copilot dltHub Pro for hosted pipelines, monitoring, and deploying Marimo notebooks as dashboards If you have ever wired up a brittle ingestion script, fought with a managed connector that did not quite fit, or wondered how agents should actually pull data into your warehouse, this episode is for you. Resources: dltHub: https://dlthub.com/ dltHub on GitHub: https://github.com/dlt-hub Introducing dltHub Pro: https://dlthub.com/blog/introducing-dlthub-pro Hugging Face + dlt for ML: https://dlthub.com/blog/hugging-face-dlt-ml Elvis on GitHub: https://github.com/elviskahoro Temporal on GitHub: https://github.com/temporalio

Vibe Check: Can AI Actually Write Spark? Live Coding w/ Databricks & Snowflake

Watch the video version for the demos and screen shares: https://www.youtube.com/live/jCQx4XvrEUk Holden Karau (Snowflake, formerly Databricks) and Lisa Cao (Databricks DevRel) joined us to dig into what it actually looks like to write Spark code with AI agents in 2026. We worked through a real example from Holden's High Performance Spark Second Edition — a Goldilocks-style exact percentiles problem across hundreds of columns — and watched Claude Code handle it from a cold-start repo, then again with proper context and a reference solution. Lisa walked through using a skill file to get Claude to write declarative pipelines the right way instead of hallucinating the syntax, and we talked about why local mode, Arrow UDFs, and the upcoming Python UDF transpilation work in Spark 4.3 matter for AI-assisted Spark development. We also covered: why the "agents trying to shut you up" failure mode shows up in code generation, the case for property-based testing as a guardrail for agentic coding, Spark 3 to Spark 4 porting as a more reliable path than one-shotting Spark 4, and where agents still struggle (dependency management, Spark internals, real stack trace debugging vs. pattern matching from Stack Overflow). Resources: Apache Spark: https://spark.apache.org & https://github.com/apache/spark High Performance Spark (O'Reilly): https://www.oreilly.com Spark testing base: https://github.com/holdenk/spark-testing-base Databricks Spark: https://www.databricks.com/spark/about Data + AI Summit (June 15–18, San Francisco): https://www.databricks.com/dataaisummit Snowflake Summit (June 1–4, San Francisco): https://www.snowflake.com/summit PySpark Data Sources: https://github.com/allisonwang-db/pyspark-data-sources PySpark SDP: https://github.com/lisancao/pyspark-sdp Distributed Computing 4 Kids: https://distributedcomputing4kids.com/ What's working for you when you write Spark with agents? Drop your patterns and gotchas below. And let us know what you want to see on future episodes. Originally streamed May 13, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/jCQx4XvrEUk

1 di 2