Gabe Cemaj works on Claude Managed Agents, infrastructure for running extended tasks with Claude without requiring every application developer to operate the agent runtime. His work spans model-serving infrastructure, ML observability, and agent execution: systems that must preserve progress when a running process fails and accommodate changes to the model directing the work.
From ML observability to agent execution
Gabe’s public profile identifies him as a Member of Technical Staff at Anthropic and previously the leader of Bloomberg’s ML Observability team. His open-source contributions include KServe, Hera, and Cloud Native Buildpacks.
These collaborative projects address different parts of deploying and running software. KServe provides model-serving infrastructure on Kubernetes. Hera lets developers express Argo Workflows in Python, define dependencies between tasks, and submit workflows to a Kubernetes cluster. Cloud Native Buildpacks addresses building application containers. The supplied contribution record establishes participation in these projects without assigning him sole ownership or particular features.
With Claude Managed Agents, applications define instructions, tools, and skills, start sessions, and consume events as work proceeds. Developers can steer or interrupt a running session. The platform supplies the agent loop and execution infrastructure that would otherwise need to be assembled and operated alongside the application.
Keeping progress outside the process
Gabe co-authored the Managed Agents architecture account with Lance Martin and Michael Cohen. It explains how the team moved away from placing the session, agent loop, and sandbox in a single container. When that container failed, the session could be lost; different failures also looked alike through the event stream, making diagnosis difficult.
Two changes separated the lifetime of the work from the lifetime of its execution environment:
Independently recoverable components: Separating the agent loop from the sandbox let either recover without requiring the entire system to restart together.
Persistent session history: Keeping conversation events outside the running loop allowed a replacement loop to resume from recorded work. It also let the team change context-management strategies without discarding the underlying history.
The team also kept credentials outside the sandbox running model-generated code. These are concrete infrastructure decisions about what survives a failure, what can be replaced, and where secrets are exposed.
Research agents that check and revisit their work
Gabe’s research-desk demonstration connects that infrastructure to an application. He built a chat interface over the session event stream and combined an SEC EDGAR skill, subagents, a custom tool, and shared memory. In an Nvidia analysis, an outcome grader checked the work against a rubric and prompted Claude to retry until it passed. The rubric supplied an explicit completion criterion beyond the agent simply ending its response.
He also demonstrated scheduled research and memory updates: a custom tool split one request into a separate session for each company, while deployments paired agents with schedules and resources. His demonstration of Dreaming, presented as a research preview, reviewed 30 days of past sessions to improve a memory store. Together, these examples show how he applies managed execution to research that spans multiple sessions, runs repeatedly, and carries information forward.
Anthropic’s first Managed Agents architecture put the session history, harness and sandbox in one container. Separating them changed failure recovery, credential handling, context management and the path to a first response.
Harness workarounds depend on model behavior. Separating interfaces lets the harness change when those assumptions become stale.
The session log preserves continuity while the harness and sandbox remain replaceable. Sandbox failure returns a decision to Claude; harness failure is recovered by reading the log.
Preserved events support different context strategies, while on-demand sandbox provisioning lets inference begin sooner. Anthropic reports about 90% lower time to first token.
Priyanka Phatak and Gabe Cemaj build from a console-created joke agent to a research desk that reads SEC filings, delegates analysis, saves memory and grades its own deliverables. The Q&A draws the practical boundaries around credentials, orchestration, shared knowledge and private data.
A chat interface sends user.message events to a session and relays the API's SSE stream through its backend to the browser.
The Nvidia task produces both a reusable company memory note and a structured scorecard. Specialists return findings; the main agent creates the deliverables.
Outcomes grade session work against a task-specific rubric and permit retries. They do not provide separate subagent outcomes or the per-session spending caps discussed in Q&A.
Vaults substitute real credentials for placeholders at egress only for allowed hosts. Private connectivity can instead use MCP Tunnels or a self-hosted sandbox with internal network access.
Multiple memory stores can accompany a session. Dreaming consolidates transcripts and memories into updated memory; automatic changes to skills, prompts and agent definitions were outside its demonstrated scope.
Priyanka Phatak and Gabe Cemaj explain how to version agent definitions, choose workspace boundaries, evaluate real behavior and keep a coordinator responsive while custom tools wait.
Keep one agent definition in YAML and synchronize deployed copies through CI/CD, including copies in separate customer workspaces.
Use individual workspaces for the customer data segregation discussed here. Session metadata records customer identity without providing that separation.
A company-research demo connects session fan-out, scheduled work and memory improvement. The Q&A then tests the practical boundaries: evaluation, observability, tenancy, scaling and where the application developer still has work to do.
A custom tool can fan one request into multiple sessions, while each session contains its own multi-agent collaboration and outcome definitions.
A deployment schedules new sessions using an agent definition, initial messages and resources. Memory remains an independent store attached to selected sessions.
Dreaming reviews past session transcripts to improve memory. Its proposed lessons still need task-level evaluations, especially when past experiences disagree.
Workspace membership grants broad access within that workspace. Multi-tenant applications must account for the absence of granular platform RBAC in the version discussed.
Managed Agents handles session infrastructure behind API calls, subject to rate limits. Developers still build the customer product, and on-premises operation was only under consideration.
▶ Watch ↗
