The Video Signal

Topic

Managed Deep Agents

All digests tagged Managed Deep Agents

Schedules for Managed Deep Agents: Cron jobs, prompts, and Slack delivery thumbnail

· 3:26

Schedules for Managed Deep Agents: Cron jobs, prompts, and Slack delivery

This video demonstrates how to implement automated, recurring tasks using Schedules for Managed Deep Agents. By configuring cron jobs, agents can run autonomously to generate and deliver structured reports (e.g., a weekly Salesforce pipeline summary) to external channels like Slack, without manual intervention. The process involves defining the schedule syntax, deploying the agent to LangSmith, and ensuring the agent has access to necessary tools and context.

Key takeaways

  1. Automated Reporting via Cron Jobs

    Schedules allow agents to send recurring messages that invoke tools or leverage context, such as generating a weekly pipeline summary for the sales team.

  2. Schedule Configuration 0:01

    Schedules are defined by creating a file in the schedules directory, specifying a cron job, a time zone, a prompt, and optional input context.

  3. Deployment and Monitoring 0:01

    The scheduled agent must be deployed to LangSmith using a deploy command, allowing users to inspect the configured cron jobs and prompts within the LangSmith UI.

Watch on YouTube Full article

Middleware for Managed Deep Agents thumbnail

· 4:42

Middleware for Managed Deep Agents

Middleware is a mechanism for extending the lifecycle of Managed Deep Agents, allowing developers to implement custom behaviors such as policy enforcement, fault tolerance, and rate limiting. The demonstration covers two primary use cases: using prebuilt middleware (like `PIIMiddleware`) to redact sensitive data before it reaches the LLM, and building custom middleware from scratch using decorators like `wrap_tool_call` for logging and auditing tool usage.

Key takeaways

  1. Middleware Functionality

    Middleware extends the agent's lifecycle to manage behaviors like policy enforcement, fault tolerance, and rate limits when interacting with tools or the LLM.

  2. PII Redaction Demo 0:01

    Using prebuilt `PIIMiddleware` automatically detects and redacts sensitive information (e.g., customer emails) from the input, preventing the data from reaching the LLM or being stored in LangSmith.

  3. Custom Middleware Development 0:03

    Custom middleware can be built using decorators (e.g., `wrap_tool_call`) and hooks to intercept and log events, such as every tool call, at specific points in the agent's process.

Watch on YouTube Full article

Share your Managed Deep Agent with your team using Slack thumbnail

· 5:04

Share your Managed Deep Agent with your team using Slack

This guide details the process of deploying a Managed Deep Agent, initially developed in LangSmith Studio, to a production environment using Slack as the primary interaction layer. The process involves running `slack init` to configure the connection, executing a deployment, completing the Slack authorization step, and finally customizing the agent's appearance and message trigger logic for optimal team integration.

Key takeaways

  1. Agent Deployment Workflow

    To connect an existing agent to Slack, run the `slack init` command, followed by a redeployment. The first deployment requires completing a Slack authorization step to link the agent to the internal workspace.

  2. Monitoring and Tracing 0:01

    When the agent is live, all user interactions (requests) are logged and traceable within the LangSmith dashboard, allowing engineers to monitor complete request traces even though the user only sees the final answer in Slack.

  3. Agent Customization 0:02

    The agent's name, description, icon, and background color can be customized by modifying the setup code in the channels directory and redeploying the agent.

  4. Message Trigger Configuration 0:03

    Two key trigger options exist: manual tagging (default) or 'trigger on all messages' (setting `trigger_on_all_messages` to true). Enabling the latter allows the agent to respond to any message in a dedicated channel, not just those directly addressed to it.

Watch on YouTube Full article

Catch Agent Regressions Before You Ship: Evals for Managed Deep Agents thumbnail

· 8:57

Catch Agent Regressions Before You Ship: Evals for Managed Deep Agents

This session details how to implement robust evaluation (evals) for Managed Deep Agents to prevent performance regressions as the agent's capabilities grow. The process involves using Harbor, which ensures each evaluation runs in a fresh container. Evals are structured into an environment (data/state), a job (instruction), and a check (verifier). The workflow is scaffolded using `mda evals init`, which can be automated by handing the task to a coding agent (e.g., Claude Code). Results and traces are managed and monitored in LangSmith, allowing for continuous evaluation and integration into nightly CI pipelines.

Key takeaways

  1. Purpose of Evals

    Evals serve two primary goals: catching regressions (ensuring changes don't break existing features) and 'hill climbing' (actively improving agent capabilities). The focus is on defining and catching regressions.

  2. Harbor's Role in Evaluation

    Harbor is bundled into Managed Deep Agents and is crucial because it builds an image around the agent, ensuring every eval runs in a fresh container. It also manages test execution to prevent environment pollution.

  3. Anatomy of an Eval 2:15

    An evaluation consists of three parts: the environment (the starting data/state), the job (the instruction, defined in a markdown file), and the check (the verifier that determines if the job was completed adequately).

  4. Automating Eval Scaffolding 2:36

    The command `mda evals init` scaffolds the necessary files (e.g., `task.md`, `Dockerfile`, tests). Using the `-i` flag allows the work to be handed off to a coding agent, which generates the initial eval suite.

  5. Production Monitoring

    Evals can be managed in production by running them nightly within a CI system. Results are logged into LangSmith, allowing developers to continuously track agent performance and stability.

Watch on YouTube Full article

Managed Deep Agents - Instructions and Context Hub thumbnail

· 5:40

Managed Deep Agents - Instructions and Context Hub

This video details how 'Instructions' define the behavior of Managed Deep Agents. These instructions are stored in a dedicated Context Hub, allowing developers to modify agent behavior directly through the UI without needing to redeploy code. The process involves syncing local changes (e.g., modifying `instructions.md`) with the production Context Hub via commands like `mda deploy`, and understanding how conflicts between local and deployed instructions can be resolved.

Key takeaways

  1. Instructions Define Agent Behavior

    Instructions are the core component defining an agent's behavior, typically placed within the system prompt. Changing these instructions immediately impacts the agent's output (e.g., changing response language from Italian to Spanish).

  2. Context Hub for Non-Code Changes 2:05

    The Context Hub allows agents to be updated by modifying instructions in a UI, which automatically propagates changes to the deployed agent without requiring code redeployment.

  3. Syncing Local and Production Instructions 3:50

    When running `MDA deploy`, if the Context Hub has been manually edited (e.g., in production), the deployment process pauses, allowing the user to choose whether to override the hub-edited instructions with the local version or vice versa.

Watch on YouTube Full article

Build a social media agent with Managed Deep Agents thumbnail

· 12:49

Build a social media agent with Managed Deep Agents

This tutorial demonstrates building an autonomous social media agent using LangChain's Managed Deep Agents (MDA). The resulting agent monitors Hacker News and X (Twitter) to generate daily drafts of post ideas, which are then delivered directly to the user via Slack. The process covers setting up the project structure, defining custom tools, implementing specialized skills, configuring persistent memory across sessions, scheduling autonomous execution, and deploying the system to a production channel.

Key takeaways

  1. Agent Initialization and Setup 2:00

    The process begins by installing dependencies using `UV tool install managed deep agents` and initializing the project with `MDA init social post assistant`. The agent's entry point (`agent.py`) is configured, specifying model properties (e.g., changing to `GPT-5.6 Luna` for cost efficiency) and defining access tools.

  2. Tooling and Data Integration 3:50

    Custom tools are built to interact with external APIs: a tool to search Hacker News (using Algolia API) and two tools for X/Twitter (`get X user timeline` and `search X posts`). Authentication requires defining bearer tokens in the `.env` file.

  3. Advanced Agent Configuration 5:50

    The agent's behavior is governed by a core instruction file (`instructions.md`) and specialized, modular knowledge packages called 'Skills.' A skill (e.g., `draft posts`) provides dynamic instructions for specific tasks like drafting or revising content.

  4. Persistence and Automation 7:50

    To maintain context across different runs, a memory file (`memory.py`) is set with the scope to 'agent.' The agent's autonomy is established by creating a schedule (e.g., `morning drafts.py`) using cron expressions to run daily at 9:00 a.m. Pacific time.

  5. Deployment and Connectivity 9:40

    The agent is tested locally via `MDA dev` (which opens the agent in LangSmith Studio) before deployment using `MDA deploy`. Slack integration requires running `mda channel add slack`, generating a manifest, and setting up necessary environment variables (Slack signing secret and bot token).

Watch on YouTube Full article