Owlcast

Watch the video version for the demos and screen shares: https://www.youtube.com/live/0q11SEogJFU

In this livestream, Lizzie Siegel (Developer Advocate at DigitalOcean) demos OpenClaw — an open source autonomous agent framework that can take real actions, not just chat. Lizzie spins up OpenClaw on a DigitalOcean Droplet, connects it to WhatsApp as the UI, and breaks down how skills work, what's possible, and what to watch out for when agents can touch real infrastructure.*

We go beyond the surface and explore:

• What OpenClaw is (and what "autonomous agent" actually means in practice)
• Why running agents on a contained VM (a Droplet) can be safer than giving access to your laptop
• How OpenClaw differs from CoWork and why guardrails matter
• Using WhatsApp as the interface (including what it looks like when you're "chatting with yourself")
• Hosting + setup basics: deploying from the marketplace, SSH'ing in, and choosing an LLM provider
• Skills and ClawHub: what a Skill.md is, how skills extend capabilities, and how people share them
• A real example skill: auto-booking reservations (and why it can cross into ToS/ethics territory)
• Risks + responsible use: automation, credential exposure, and where agents can go off the rails

If you're experimenting with autonomous agents, curious what it looks like to run them against real infrastructure, or deciding when you want agent autonomy vs workflow guardrails, this episode is for you.

Resources:

• Lizzie's working end-to-end demo (7 min): https://www.youtube.com/watch?v=owyr56T86BA
• Run OpenClaw on DigitalOcean (tutorial): https://www.digitalocean.com/community/tutorials/how-to-run-openclaw
• ClawHub (skills directory): https://clawhub.ai/
• Exposures Watchboard: https://openclaw.allegro.earth/
• Maton AI (connect Gmail/Drive/Calendar/Slack): https://www.maton.ai/
• Temporal for AI: https://temporal.io/solutions/ai

Heads up: an API key was briefly visible during the stream and has since been revoked. Never share API keys publicly — treat them like passwords and rotate immediately if exposed.

> 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

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/

Watch the video version for the demos and screen shares: https://www.youtube.com/live/YXjbfc8ioV8

In this livestream, Chad Retz (Temporal SDK maintainer, 4+ years at Temporal) digs into the open source code that powers your workflows.

We go beyond the surface and explore:

• Why Temporal is fully MIT licensed (and why that matters)
• The difference between the Temporal Server and the SDKs
• How the Python SDK turns your code into durable, replayable workflows
• What really happens when you call execute_workflow
• How workers poll, replay history, and deterministically execute your code
• Interceptors, activations, commands, and the Rust core
• Error handling, retries, and gRPC under the hood
• How to contribute to Temporal's open source repos
• How Chad uses AI (Claude, Opus) to build SDK features across languages

If you've ever wondered how Temporal makes your code durable or why the SDKs are so "smart" then this is for you.

Explore the repos: https://github.com/temporalio

Originally streamed February 20, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/YXjbfc8ioV8

> 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

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/

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

Watch the video version for the demos and screen shares: https://youtu.be/rAY1ERVJLY4

Terry Ryan from Google walks us through Naval Plan, a real app he built (and actually uses) to plan sailing trips using ADK Go. The app combines agentic research — pulling from old sailing forums and local knowledge — with deterministic API calls for tides, weather, and sunrise/sunset data. We dig into how the agents are architected, the quirks of working with Google Search as a tool in ADK, and Terry's dev workflow using Gemini CLI.

Topics covered:

• Building Naval Plan: an agentic sailing trip planner with ADK Go
• Mixing agentic research with deterministic API tools (tides, weather, sunrise/sunset)
• ADK agent architecture: subagents, tool composition, and the Google Search tool workaround
• Structured JSON output from agents and how to make it reliable
• Dev workflow: Gemini CLI in YOLO mode, git-based rollback, and prompt management
• Using LiteLLM for multi-model support in ADK
• Tool count limits and context window considerations
• Upcoming Temporal + ADK integration

Links mentioned:

• ADK: https://adk.dev
• Naval Plan walkthrough video: https://www.youtube.com/watch?v=kwSVtQ7dziU
• Charm (Go terminal UI libraries): https://charm.sh
• Google Cloud Next (Las Vegas): https://www.googlecloudevents.com/next-vegas

Originally published April 6, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://youtu.be/rAY1ERVJLY4

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

Watch the video version for the demos and screen shares: https://www.youtube.com/live/CXSHANydwig

In this livestream, Donald (AI Foundations engineer at Temporal) and Mark Biza (DX engineer at Vercel) join us for a Vibe Check on skills — what they are, how to build them, and what they unlock for AI-assisted development. Donald previews the upcoming Temporal Agent Skill and live-demos it in Claude Code, while Mark walks through skills.sh, the distribution platform Vercel built to share skills across agents and teams.

We go beyond the surface and explore:

• What Claude Code skills actually are — markdown files with YAML frontmatter that give coding agents structured, domain-specific context
• Why skills matter: how they guide agents past incomplete or inaccurate training data toward real best practices
• How the Temporal Agent Skill is structured — a shared core for cross-language concepts plus language-specific folders for Python, TypeScript, Go, and more
• A live demo: Claude Code building a durable payment workflow using the Saga pattern — unprompted — because it was encoded in the skill
• Why being able to run and iterate on workflow code (not just write it) is the key unlock for agents debugging Temporal apps
• How skills.sh works — installation via npx skills add owner/repo, the leaderboard, auditing, and community contributions
• Vercel's Chat SDK skill and how it scaffolds agents for Slack, Discord, Teams, and WhatsApp
• Using skills outside of code — marketing, SEO, copywriting, and motion graphics with Remotion
• Skills vs. MCP: why the future likely uses both together, and where each fits
• The case for skill cross-dependencies and skill bundles — a feature Donald and Mark noodle on live

If you're building on Temporal, experimenting with Claude Code, or trying to understand how to give your coding agents better guardrails and domain knowledge, this episode is for you.

The Temporal Agent Skill is launching next week — look for it on skills.sh.

Resources:

• Temporal Agent Skills repo: https://github.com/temporalio/skill-temporal-developer/tree/dev
• skills.sh: https://skills.sh/
• Vercel Agent Resources & Skills: https://vercel.com/docs/agent-resources/skills
• Temporal with AI: https://docs.temporal.io/with-ai
• Temporal for AI: https://temporal.io/solutions/ai
• Temporal Community Slack (share your skill feedback here): https://temporal.io/slack

Originally streamed March 13, 2026 on Vibe Check Temporal YouTube channel and you can watch the full episode at: https://www.youtube.com/live/CXSHANydwig