In 1988 The Common Lisp Condition System was formally introduced by the X3J13 committee, responsible for the ANSI standard. It was a radical idea: The code that /detects/ an error should not decide how to /recover/ from it. Instead, the signaler establishes named recovery options—restarts—and lets a handler higher up the stack choose which one to invoke. The decision belongs to whoever has the broader context. This was ahead of its time. For 35+ years, the "broader context" was either a human in the debugger or a programmer who knew at compile time which restart to pick. Both worked fine. Then LLMs showed up. An agent monitoring a data pipeline encounters a validation error. Three restarts available. No hardcoded strategy. The agent needs to reason about system goals, weigh tradeoffs, adapt to context it wasn't explicitly programmed for. The architecture was already right. What was missing: semantic context for the handler. Restarts come with names and descriptions. Agents need to know what the system is /trying to achieve/. What failed and why. What each recovery option costs. Why these specific restarts exist in the first place. When you add structured intent metadata—goals, failure modes, design rationale—the agent can map recovery options to system objectives. Same restarts. Profoundly different decision-making surface. I built Telos to capture this. It makes the why behind code queryable at runtime. Combined with conditions and restarts, you get agent-legible error recovery. The condition/restart protocol already separates mechanism from policy. It supports multiple recovery options without the signaler knowing which will be chosen. It allows the handler to be arbitrarily far—in code, in time, in understanding—from the signaler. It's an architecture perfect for agentic systems. And, yes, Common Lisp has an ANSI standard. Blog post with full working CSV validator example: https://lnkd.in/dSbuDK6J #commonlisp #lisp #agents #llm #programming #code #quasilabs