Managed Deep Agents v0.9: Zeitpläne, Konfiguration pro Run und Slack-Reaktionen

Die wichtigsten Punkte

• Von Agenten erstellte Zeitpläne: Agenten können aus einem Gespräch heraus Erinnerungen und wiederkehrende Aufgaben einrichten.
• Konfiguration pro Run: eine Bereitstellung kann Modell, Skills und Tools für jeden Run auswählen.
• Slack-Reaktionen: Agenten bestätigen Nachrichten, bevor sie antworten.

Heute veröffentlichen wir Managed Deep Agents v0.9, mit neuen Funktionen, mit denen Agenten ihre eigenen Follow-ups planen, sich bei jedem Run neu konfigurieren und auf Slack-Nachrichten reagieren können.

Diese Updates erleichtern den Aufbau interner Agenten, die in Slack oder Ihren eigenen Kanälen leben und eher wie Teamkollegen arbeiten.

Agenten ihre eigene Arbeit planen lassen

Das neue Schedules SDK ermöglicht es Agenten, mitten im Gespräch Erinnerungen, Follow-ups und wiederkehrende Aufgaben zu erstellen, sodass sie Anfragen wie "Erinnere mich morgen daran" bearbeiten können.

Der Agent erstellt den Zeitplan selbst während eines Gesprächs, der Zeitplan läuft als die Person, die ihn angefragt hat, mit deren Berechtigungen und Verbindungen, und die Ergebnisse kehren in denselben Kanal zurück.

Einen Zeitplan aus einem Run heraus erstellen:

await schedules.create(owner={"type": "user"}, cron="0 9 * * 1-5", timezone="America/Los_Angeles", prompt="Write the daily digest.")

Am nützlichsten ist es hinter einem Tool, sodass die Nutzer Ihres Agenten Zeitpläne einfach durch Chatten erstellen, auflisten, aktualisieren und löschen können. Hier ist ein Erinnerungs-Tool:

from langchain.tools import tool
from managed_deepagents import schedules

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

Der Agent übergibt einen Prompt und einen Cron-Ausdruck, und jedes Mal, wenn der Cron auslöst, startet LangSmith einen neuen Run mit diesem Prompt. Zeitpläne erben den Kanal, in dem sie erstellt wurden, sodass die Ergebnisse dorthin zurückgesendet werden, wo die Anfrage herkam: eine Wochentags-Erinnerung, die in Slack angefragt wurde, postet bei jedem Run eine neue Nachricht in dieses Gespräch. Einmalige Zeitpläne (at statt cron) antworten im ursprünglichen Thread, was für Follow-ups wie "prüfe in einer Stunde diesen Deploy" geeignet ist.

Agenten pro Run konfigurieren

Ein Agent kann jetzt dynamisch pro Runkonfiguriert werden. Richten Sie den Agenten als aufrufbare Funktion ein: Er erhält die runtime zu Beginn jedes Runs und gibt eine define_deep_agent Definition zurück, in der er Modell, Anweisungen, Skills, MCP-Server und Sandbox für diesen Run auswählt.

Statt eine nahezu identische Kopie desselben Agenten für jedes Team oder Repository zu pflegen, betreiben Sie eine einzige Bereitstellung. Dies ermöglicht es Ihrer Bereitstellung, flexibler zu arbeiten, wobei eine einzelne Agent-Bereitstellung basierend auf dem Kontext — etwa dem Kanal oder Nutzer, aus dem die Anfrage stammt — für verschiedene Teams oder Anwendungsfälle angepasst werden kann.

Nehmen wir an, ein interner Slack-Agent bedient mehrere Teams. Ihre Agent-Funktion kann prüfen, aus welchem Kanal ein Run stammt, und Billing-Skills für die Finanzabteilung oder einen Incident-Response-MCP-Server für das Plattform-Team laden. Das unterscheidet sich von Anweisungen, die dem Modell sagen, wann es einen Skill verwenden soll: Die Konfiguration wird festgelegt, bevor das Modell läuft, sodass der Agent niemals Skills oder MCP-Tools außerhalb seiner Konfiguration sieht. Das hält seinen Kontext klein, dient zugleich als Zugriffskontrolle und ermöglicht es Ihnen, das Modell selbst auszuwählen, was das Modell nicht kann.

Im Allgemeinen verhindert es nicht-deterministische Ausgaben, bei denen das Modell damit beauftragt ist, das Toolkit auszuwählen, obwohl wir genau wissen, welcher Satz an Tools dem Agenten zur Verfügung stehen sollte.

Dieselbe Idee funktioniert auch für einen Coding-Agenten, der für jedes Repository unterschiedliche Skills und ein günstigeres oder leistungsfähigeres Modell lädt:

# agent.py: one coding agent, configured per repo at the start of each run
from dataclasses import dataclass

from managed_deepagents import ManagedServerRuntime, define_deep_agent

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"],
    },
}


@dataclass
class AppContext:
    repository: str = ""


def agent(runtime: ManagedServerRuntime[AppContext]):
    execution = runtime.execution_runtime
    context = execution.context if execution is not None else None
    repo = context.repository if context is not None else None
    config = REPOS.get(repo, REPOS["storefront"])
    return define_deep_agent(name="open-swe", context_schema=AppContext, **config)

‍‍


Die Funktion liest runtime.execution_runtime.context und greift auf einen Standardwert zurück, wenn keiner vorhanden ist, etwa bei Channel-Runs oder wenn der Agent Server den Agenten lädt, um sein Schema zu lesen. Aufrufer wählen die Konfiguration mit dem context:

# Same deployment, different repo: just change the run context
await client.runs.create(
    thread_id,
    "open-swe",
    input={"messages": [{"role": "user", "content": "Fix the flaky refund test."}]},
    context={"repository": "payments-service"},
)

Auf Slack-Nachrichten reagieren

Slack-Reaktionen zeigen dem Absender sofort, dass der Agent seine Nachricht aufgenommen hat, auch wenn der Agent eine Weile überlegt und Tools aufruft, bevor er antwortet. Reaktionen sind standardmäßig aktiviert (👀), und die neue reactions -Option auf deinem Slack-Channel erlaubt es, sie zu deaktivieren, ein anderes Emoji zu wählen oder eines pro Nachricht festzulegen. Dieses Beispiel verwendet 🐛, wenn eine Nachricht etwas Kaputtes erwähnt, und ansonsten 👀:

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)

Reaktionen können einfach sein. Es ist jedoch möglich, deine Reaktionsantwort mit einer Funktion zu konfigurieren, die ein Modell aufruft, um ein genaueres Emoji auszuwählen. Ein Entscheidungsmodell wie Jev hält das schnell und günstig; die Slack-Channel-Dokumentation führt durch ein vollständiges Beispiel.

Erste Schritte

Managed Deep Agents v0.9 ist ab heute als Public Beta verfügbar. Mehr dazu findest du in der Managed Deep Agents-Dokumentationoder lege los mit:

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

‍ICYMI: v0.8 brachte Per-User-Memory, benutzerdefinierte HTTP-Channels zum Auslösen von Runs aus beliebigen Diensten, integrierte Websuche powered by Parallel und mehr. Lies den v0.8-Beitrag.

‍