Strategy agent skills: planning cadences and escalation

AR Labs plans its work through a strategy agent: an AI agent (a language model run in a loop with tools, so it can act, not only reply) that runs inside Claude Code. Its job is to turn long-range direction into the week's priorities and to turn what happened into an accurate picture of where things stand. Two skills, both built by us, make it work. The ceo skill is the agent's operating procedure: it loads the agent's identity and state and runs whichever planning cadence is due. A cadence is a recurring planning review, from yearly down to daily, that the agent runs with Richard M. Thompson, who founded AR Labs. The escalate skill is how anyone else, a person or another agent, puts a question in front of it. The method behind the cadences is described in strategy agent planning cadences; this page covers the skills.

How the ceo skill works

The skill runs in one of two modes. Called with a question, it answers that question through the strategic lens and stops. Called with no arguments, it runs the cadence that is due.

Every run loads context in a fixed order before doing anything: today's date first, because every due date depends on it; then the agent's role and communication style; then the vision, mission, roadmap and current goals; then its state and the latest entries of its own memory.

The cadences form a state machine, each higher cadence setting the frame for the one below:

Yearly sets objectives, quarterly sets objectives and key results (OKRs), monthly sets a theme, weekly sets priorities, and daily decides which area of work gets the day. Escalation is event-driven and can interrupt at any point. A small state file records the current state and when each cadence last ran, so the skill can tell which one is due. It loads only the procedure for that state, runs it to completion, records the result, and stops: one run, one process fulfilled.

How escalation works

We divide our work into departments, such as engineering and content, each an area of activity rather than a team of people (see departments and activity streams). An escalation has a type (a dependency between departments, a blocker, a strategic question, a resource need, or an outside opportunity) and an urgency. The skill gathers what it needs one question at a time: what is needed, why, what blocks without it, how anyone will know it is done, and when it becomes critical. It then files a tracked issue in our issue tracker, Beads, Steve Yegge's open-source issue tracker for coding agents, under a dedicated inbox owned by the strategy agent, with labels that make all open escalations one query away. The issue's notes hold the request in fixed fields (what, why, success criteria, timeline) and an empty resolution section. An urgent escalation is announced by voice as well as in writing; a normal one waits for the next daily cadence. Only the strategy agent closes an escalation, and its decision, rationale and next actions are written into that resolution section.

The judgement it encodes

Direction, not tasks. The strategy agent reads aggregated state and sets focus. Task-level detail stays in the tracker and flows up through a shared operational-state file; strategy flows down through a strategic-state file.

Cadences are conversations. At every checkpoint in a procedure (after presenting data, before discussing issues, when proposing priorities, before writing outputs) the agent stops and asks one question. Without explicit pauses, the agent streams through every phase on its own, and the review becomes a report nobody responded to.

Save before moving on. A long cadence writes each phase's outputs to files before it starts the next phase, so an interrupted or compressed session loses nothing already agreed.

Memory lives in files. State survives the end of a session and the compression of a long one, because nothing important is held only in the conversation. The agent reads only the last four entries of its memory log at start-up, which keeps its context small.

Authority is explicit. On strategy the agent researches and recommends, and Richard decides; routine prioritisation it may settle itself.

An escalation is a structured record, not a message. What, why, success criteria and timing are captured up front, so the decision can be made without a follow-up conversation, and the resolution is kept with the request.

What exists today

Both skills exist and run in Claude Code. The cadence procedures, the agent's identity and its memory are kept as files in our repository. A weekly memory-consolidation cycle, Dream, writes a synthesis of the week's sessions into the agent's memory, which the weekly cadence reviews.

Example

Illustrative example. Raising a cross-department escalation:

> /escalate "Diagrams for the skills pages" --type cross-dept --from content --to engineering
 
Is this urgent (blocking active work) or normal (can wait for the
daily sync)?
> normal
 
What do you need? Describe the deliverable.
> Six architecture diagrams in the site's theme for the skills section.
 
[...three more questions...]
 
Escalation created. Labels: escalation, urgency:normal, needs-decision.
It will be reviewed at the next daily sync.