Strategy agent planning cadences

AR Labs plans its work through a strategy agent that runs a fixed set of planning cadences: recurring planning reviews held yearly, quarterly, monthly, weekly and daily. The strategy agent is an AI agent (a language model run in a loop with tools, so it can act, not only reply) with a narrow job: turn a long-range vision into this week's priorities, and turn what happened this week into an accurate picture of where the company stands. This page describes the method for anyone running AI agents against a plan; our actual goals and priorities are not published. Richard M. Thompson, who founded AR Labs, keeps every strategic decision; the agent prepares, records and cascades them.

How it works

The agent is not a persistent personality. It is a skill (packaged instructions, with any scripts, that an agent loads only when a task needs them), run in a Claude Code session on request and described on strategy agent skills. It rebuilds its understanding from files every time it starts. Its boot sequence loads, in order, its role definition, the company's vision and roadmap, the state-machine rules, its current position (which cadence is due, the latest strategic and operational state) and its own decision log. Memory lives in files under version control, never in a context window, so a session can be cleared or compacted without losing anything.

The cadences form a state machine. Each state has a trigger, an authority level and a primary output.

Cadence	Trigger	Primary output
Yearly strategic	Year boundary	Vision check, roadmap, activity map, annual objectives
Quarterly OKR	Quarter boundary	Graded previous quarter, new objectives and key results
Monthly strategic	Month boundary	Monthly goals per department, a strategic theme
Weekly tactical	Week boundary	Department priorities for the week
Daily sync	Day boundary	Today's focus and blockers
Escalation	Any time	A decision package for Richard

OKRs (objectives and key results) are the standard goal-setting format: an objective states what the company wants, and each key result states how it will know.

Strategy cascades down through the cadences; blockers and learnings flow back up. In the figure, each review's bar zooms into one slice of the bar above it, so a week is planned inside its month and a month inside its quarter, while the arrows on the right name what passes down and what comes back up at each step.

Two channels: operational state up, strategic state down

The agent sits between two documents. The operational state is written by the departments (see departments and activity streams) and records their focus, blockers, stream health and an activity log of what shipped. The strategic state is written by the agent after each cadence and records the current theme, the week's priorities, key decisions and strategic risks. Departments read it; the agent reads the operational state. One writer per file keeps the channels from contradicting each other.

The agent sees aggregates, never tasks. Individual tasks live in Beads, Steve Yegge's open-source issue tracker for coding agents, which stores its records in git; one tracked task is a bead. The agent reads counts and health from the tracker but does not create or manage beads. When it decides something, it updates the strategic documents, and each department reads those and creates its own work.

Interface rules between cadences

Five rules keep the cadences from overwriting each other:

1. Read from your parent's output. The weekly cadence reads the monthly goals, not the quarterly OKRs directly.
2. One level up. A cadence may propose a change only to the cadence directly above it. A weekly finding can change a monthly goal; it cannot reach into the quarter.
3. Write your own outputs. Each cadence owns its documents; its parent's documents are read-only to it.
4. Goals are append-only. An achieved goal is marked done with its date and stays in the table; a follow-on goal is appended below it.
5. Ad hoc strategy sessions have restricted scope. They may record a decision and a pending-change flag, but the goal tables change only through the normal cascade.

Every cadence phase ends at a gate (a point work cannot pass until a condition is met) where Richard reviews the output before the agent continues. That gate is the human-in-the-loop layer that enforces the rules above.

Authority levels

Decisions are sorted on a five-level delegation scale, from "execute exactly as instructed" to "act independently". Routine prioritisation and small reallocations of time sit at the autonomous end; strategic direction, large reallocations and anything that reverses one of Richard's decisions sit at the recommend-and-wait end. The scale also sets when the agent must escalate (see escalation between agents).

Two further rules govern the agent's role. It directs and does not execute: when departmental work comes up mid-cadence, the agent records it as that department's focus and hands it to a department session. And every approved pivot carries a cascade checklist naming each downstream document that must change, because a decision recorded only at the strategic layer never reaches the material people actually see.

Failure modes as design requirements

A strategy agent that runs in a single context window, reading a deep hierarchy of documents, tends to fail in recognisable ways. We name each failure mode and treat it as a requirement for the next version of the harness (everything around the model that shapes what an agent does: the agent program, its instructions, skills, hooks, tools and checks):

• Snapshot reasoning: deciding from the most recent operational document instead of loading the authoritative layer above it.
• Classification drift: a fact reclassified in a weekly document silently overrides its strategic classification.
• Unwatched-commitment decay: a dated commitment erodes across cadences because nothing tracks its burn-down.
• Authority overreach: making and recording a decision above the agent's level instead of recommending.
• Confident and wrong: a well-argued, internally consistent answer that no internal check flags.
• Boundary offered up: stating a constraint and then offering to cross it if the user agrees.
• Proxy metric graded as progress: scoring work by an easy number that measures something else, such as an open-task count that rises with scope.

The guards proposed against them are structural, and are designs rather than running code: forced loading of the authoritative layer before any strategic decision, a reconciliation check between operational and strategic classifications, burn-down monitoring on dated commitments, authority gates that turn a ruling into a recommendation, a critic pass before any durable write, freshness checks on every input before grading, and reporting closed, created and open counts side by side.

What exists today

The agent runs as a Claude Code skill. Each cadence is an interactive session with Richard, following written procedures for each cadence and writing to version-controlled state files. A dashboard and a weekly page present the results (see AI agent operations dashboards and goal maps), and the strategic alignment skill helps pick one project when focus breaks down between cadences. An always-on agent process, a voice interface and an event-driven mode, in which the agent reacts to changes in a continuously updated model of the company rather than waiting for a cadence boundary, are designs and are not running.