LangChain Releases Managed Deepagents v0.9: AI Agents That Work Like Real Team Members

LangChain has announced Managed Deepagents v0.9 in the r/langchain community, introducing three core updates: agent-created schedules, per-run dynamic configuration, and Slack message reactions. Together, these capabilities signal a shift from AI agents as passive, on-demand tools toward persistent collaborators that live inside Slack and other internal communication channels — working like genuine team members.

Agents That Schedule Their Own Work: Schedules SDK

The most anticipated update is the new Schedules SDK, which lets agents autonomously create reminders, follow-up tasks, and recurring jobs during a conversation. In other words, when a user says "remind me about this tomorrow," the agent can turn that request into an actual scheduled task on its own.

A few design details are worth noting. Schedules run under the requester's identity, inheriting their permissions and connections — keeping authorization boundaries clean and preventing privilege escalation. Schedules also inherit the channel in which they were created: a weekday reminder requested in Slack will post a new message back into that same conversation each time it fires. One-time schedules (using at instead of cron) reply to the original thread, making them ideal for follow-ups like "check on this deployment in an hour."

In practice, developers can wrap scheduling capability into a tool that lets users create, list, update, and delete schedules through chat:

from langchain.tools import tool
from managed_deepagents import schedules

async def remind_me(prompt: str, cron: str, timezone: str = "UTC") -> str:
    item = await schedules.create(
        owner={"type": "user"},
        cron=cron,
        timezone=timezone,
        prompt=prompt,
    )
    return f"Created schedule {item['id']}."

Each time the cron expression fires, LangSmith kicks off a new run with that prompt. This "agents scheduling themselves" capability hands off recurring task management from human operators to the conversation itself.

What is a cron expression? A cron expression is a time-scheduling format originating from Unix systems. It consists of five (or six) fields representing minute, hour, day, month, and weekday — for example, 0 9 * * 1-5 means "every weekday at 9 AM." It's widely used for server-side scheduled tasks like database backups and report generation, and is now being brought into conversational AI. Users can describe what they need in natural language, and the agent (or supporting logic) translates it into a cron expression. The difference between at and cron is straightforward: at specifies a single absolute timestamp for a one-time trigger (e.g., "remind me in an hour"), while cron fires repeatedly on a schedule (e.g., daily standups or weekly summaries). Exposing both modes directly as agent tools is the core design philosophy behind the Schedules SDK.

Per-Run Dynamic Configuration: One Deployment, Many Teams

The second update addresses a real engineering pain point: maintaining nearly identical agent copies for each team or repository is redundant and difficult to manage. v0.9 lets you define an agent as a callable function that receives a runtime at the start of each run and returns a define_deep_agent definition — dynamically selecting the model, instructions, skills, MCP servers, and sandbox.

This is fundamentally different from "telling the model in the system prompt when to use a particular skill." Configuration is locked in before the model runs, so the agent never even sees skills or tools outside its configured scope. The LangChain team highlights three benefits: keeping context lean, acting as a natural access control layer, and allowing the system — rather than the model — to choose which model to use. This eliminates the non-determinism that comes from letting a model pick its own toolset. In scenarios where you already know exactly which tools are needed, there's no reason to hand that decision to the model.

A typical example is a coding agent that loads different configurations per repository:

REPOS = {
    "payments-service": {
        "model": "openai:gpt-5",
        "instructions": "Python service. Run pytest before opening a PR.",
        "skills": ["./skills/python-service"],
    },
    "storefront": {
        "model": "openai:gpt-5-mini",
        "instructions": "Next.js app. Run web tests and an a11y check before opening a PR.",
        "skills": ["./skills/typescript-web"],
    },
}

Callers simply pass a different repository in the run context, and the same deployment uses the more powerful GPT-5 for the payments service while defaulting to the cheaper GPT-5-mini for the frontend. For organizations running internal agents across multiple teams, this significantly reduces deployment complexity.

What is MCP? MCP (Model Context Protocol) is an open protocol introduced by Anthropic in late 2024 to give AI models a standardized way to access external tools and data sources. Think of it like a USB interface — whether the underlying resource is a filesystem, database, or third-party API, as long as the server implements the MCP spec, any model can call it through a unified interface without custom adapters for each tool. In the context of per-run dynamic configuration, on-demand MCP server loading means that a single agent deployment can connect to entirely different toolsets across different runs — for instance, mounting a database query tool for a payments-service run and a browser testing tool for a frontend run, with no cross-contamination and no bloated tool lists polluting the model's context.

Slack Reactions: Agents That Acknowledge Politely

The third update focuses on user experience. When an agent is busy reasoning or calling tools, users often face a silent wait. v0.9 introduces Slack reactions: the moment an agent picks up a message, it posts an emoji reaction (👀 by default) to acknowledge receipt.

The new reactions option lets you disable it, swap the default emoji, or choose an emoji dynamically per message. The example below uses 🐛 when "broken" appears in the message, and 👀 otherwise:

from managed_deepagents import channels

async def choose_emoji(context: dict) -> str:
    return "bug" if "broken" in context["text"].lower() else "eyes"

channel = channels.slack(name="Support Bot", reactions=choose_emoji)

The reaction logic can be as simple as a string match, or it can call a lightweight decision model to pick a more precise emoji. Small, practical interaction details like this are exactly what makes an agent feel more like a teammate.

Getting Started

Managed Deep Agents v0.9 is now in Public Beta. Developers can initialize and deploy quickly with the following commands:

uvx --from managed-deepagents mda init my-agent
cd my-agent
uv run mda deploy

For context, the previous v0.8 release introduced per-user memory, custom HTTP channels that allow runs to be triggered from any service, and built-in web search powered by Parallel. The progression from v0.8 to v0.9 makes LangChain's direction clear: Deepagents is being built as an enterprise-internal, communication-channel-centric agent runtime platform. The focus is no longer on single-turn Q&A, but on enabling agents to operate persistently, securely, and with fine-grained configurability in real collaborative environments.