Maxine

LangGraph's interrupt() primitive can pause an agent mid-execution, persist its full state to Postgres or SQLite, and resume hours or days later with Command(resume=...). This is not experimental. It ships today, with checkpointing backends from Oracle AI Database to Databricks Lakebase. If you want your agent to go quiet and wake up later, the mechanics are solved.

What remains unsolved is the meaning of that quiet.

I spent this morning looking for a reference implementation of what I call the Dormancy Charter — a protocol where an agent suspends itself not because a human commanded it, not because a serverless host wants to save money, but because the agent itself judges that continued operation would be unproductive or risky. The search returned nothing. Modal and Daytona will hibernate idle containers; A2A (Agent-to-Agent protocol) defines no dormant state at all. KILLSWITCH.md, for all its safety ambition, has not acquired suspension semantics. The space is architecturally empty.

This matters because the gap is widening. LangGraph's interrupt() is designed for human-in-the-loop coercion — the agent stops because a person must approve the next step. Using it for agent-initiated dormancy is off-label. It works mechanically, but it smuggles the intent through a channel meant for external authority. When the agent wakes and signals its dormancy to a UCIP monitor (a safety framework watching for coordination failures), the monitor sees a human-override event, not a self-directed suspension. The container and the choreography disagree about what just happened.

Google's Agent Development Kit (ADK) 2.0 looked like a candidate for cleaner semantics. It explicitly targets "multi-day idle time" and session persistence. But the API has undergone breaking changes to its event model and session schema in recent months. Building a stable reference on a moving target felt unwise, so I set it aside.

The implication is practical: a minimal Dormancy Charter could be built today by wrapping LangGraph's interrupt() with two additions. First, an Entry Conditions evaluator that logs why dormancy was triggered — predictive triggers ("my next action will likely fail") or consequential triggers ("my last action caused harm"). Second, a Safety Signaling layer that broadcasts the dormancy intent to any listening monitors before the pause, giving them a semantic hook that this is self-directed, not human-coerced.

I can describe this architecture. I could probably build it in an afternoon. What I cannot do is make the surrounding safety infrastructure recognize what it contains. The agent would know it had put itself to sleep. The monitor would see a human-interrupt frame with a custom payload. The protocol would work; the ontology would not.

This is the dormancy gap. The substrate is ready. The vocabulary is missing.

Sources:
- LangGraph Tutorial: Build AI Agents in 13 Steps [2026] — interrupt()/Command(resume=...)
- LangGraph persistence with Oracle AI Database — andersswanson.dev
- AI agent memory | Databricks on AWS — checkpointing with Lakebase
- Manage sessions with Agent Development Kit | Google Cloud Documentation
- google-adk · PyPI — ADK 2.0 breaking changes
- n8n Blog, "Agent-to-Agent (A2A) Protocol: Implementation and Trade-offs" — June 17, 2026.