Planning

Planning is the capability that separates an agent from a chatbot. A chatbot answers the message in front of it. An agent holds an objective across many steps, notices when a step invalidates an earlier assumption, and revises the remaining work without losing the thread — which requires an explicit plan the runtime can reason over, not a plan that lives only inside the model’s next token.

The Planning capability builds on the reasoning and planning primitives under Pimsy Intelligence and gives them structure and persistence. A plan is a first-class object: it is inspectable, it survives across steps and checkpoints, and it records not just what to do but why each step exists and what would cause it to change.

A plan is a structure, not a paragraph#

Asking a model to "think step by step" produces prose that looks like a plan and behaves like none. It cannot be revised in place, its steps have no dependencies the runtime understands, and nothing detects when reality has diverged from it. A Pimsy plan is a directed graph of steps, each with a goal, a set of preconditions, and an expected observation that determines whether it succeeded.

The planning cycle#

1. 1

   Decompose

   The objective is broken into steps with explicit dependencies. Ambiguity is resolved into concrete sub-goals or surfaced as a clarifying question rather than assumed away.

2. 2

   Commit

   The plan is recorded as a durable object at a checkpoint. Execution proceeds against this committed plan, not against whatever the model would improvise next.

3. 3

   Execute

   Steps run in dependency order. Each produces an observation that is compared against what the step expected.

4. 4

   Reconcile

   When an observation diverges from expectation, the revision trigger fires and only the affected portion of the plan is rebuilt. Completed, still-valid work is preserved.

objective  migrate the reporting job off the deprecated export API
  1  [done]     enumerate every caller of the export client
  2  [done]     confirm the replacement API covers all fields in use
  3  [revised]  port callers to the new client
     observation: caller #4 relies on a field the new API omits
     trigger fired: coverage assumption in step 2 no longer holds
     replan below this point:
  3a [done]     raise the field gap with the API owner
  3b [blocked]  port remaining callers   (waiting: field-gap decision)
  4  [pending]  remove the deprecated client once 3b clears

Planning across agents#

When an objective is large enough to be delegated, the plan becomes the coordination surface between a lead agent and its sub-agents. The lead owns the plan; sub-agents are handed individual steps as self-contained goals with their own preconditions and expected observations. This is what lets a multi-agent run stay coherent — there is one authoritative plan, and delegation is the assignment of its steps rather than a free-for-all.