Ari’s Space*   est. 2026
Skip to content
ari*s space[ a. ]
← Libraryworkflows / 2026-08-02

Agentic Progressive Improvement: snags as nested units

Keep the main seat on the real task. Mid-session snags become internal improve units with risk tiers and a skim line, not a second design chat.

10 parts / Hover to explore. Click to read.

Keep the main seat on the real task. Mid-session snags become internal improve units with risk tiers and a skim line, not a second design chat.

Main task continues
       | snag
       v
 classify tier + local ledger
       |
 bounded improvement unit
       |
 check -> digest -> main task

T3: ask. T4: prepare only.
A repair gets its own scope, history and return without taking over the original task. Uncertainty raises the tier; serial fallback must not be presented as independent peer work.
Agent context pack

You are in the middle of the real task when a tool path breaks. Fixing it in the main conversation could swallow the next hour. Turning it into another design discussion could do the same.

This method gives the snag a bounded job of its own: classify its risk, record it locally, assign the work and return only what the main conversation needs.

The version described here is 0.1.0-rc.1, from the August 2026 release account. It described an open MIT method and a member convenience kit with a first-run pack, seat snippets, examples and a scrubbed skill copy. The kit packages the method; it does not make the method exclusive.

Keep the original task in the main seat

A broken import, a wrong default path or a recurring flake may need attention without becoming the new purpose of the session.

The orchestration seat assigns a tier and adds a local ledger entry. An improve agent handles the small internal brainstorm, then gives mechanical work to builders within the tier and denylist. For T0 to T2, that discussion stays inside the unit rather than becoming another conversation with the operator.

The main seat continues the original task. The unit returns a digest and, where visibility is required, one skim line. Green T0 hygiene can stay silent when its ledger and undo story are present. Some T1 work can also return without a separate announcement, within its stated limits.

  Operator  <->  Orchestration seat  (real task)
                        |
                        | spawn improve unit
                        v
                 Improve agent
                 (nested brainstorm)
                        |
                        | builders (+ optional auditor)
                        v
                 Local trail + digest
                        |
                        v
              skim line if tier needs it
              silent OK for green T0 (ledger + undo)

Role graph doodle: orchestration seat, nested improve agent, and builders

The role graph is an illustration. The responsibilities are below.

RoleResponsibility
Orchestration seatKeep the real task moving, assign improve units and retain the skim
Improve agentRun the internal brainstorm; remain non-operator-facing for T0 to T2
BuildersMake mechanical changes within the tier and denylist
Optional auditorCheck risk or scrub when the tier calls for it

Bound the improvement work too

An improvement process can become its own distraction. The method gives it hard limits:

  CAPS (hard)
  --------------------------------
  <=3 concurrent improve units / session
  <=2 retries on the same error class
  then escalate: needs-operator
  same model as the orchestration seat
  (mechanical builders may use local only with headroom)

That means at most three concurrent improve units per session, at most two retries for the same error class, then escalation as needs-operator. The improve agent inherits the orchestration seat's model. Mechanical builders may use local models only when there is headroom.

Session caps card: at most three concurrent units, two same-error retries, then needs-operator

When a change needs to be visible, use the public skim format:

↑ improve: <what> · T# · <ref> · undo:<cmd>

Public skim re-entry card showing the improve skim line pattern

Keep the rule with it:

Silent green T0 is for hygiene with a ledger and undo, not for method, remotes, or secrets. Unsure → bump tier. T3 ask. T4 prepare only.

Uncertainty raises the tier. It is not a reason to choose the easier permission path.

Why use a nested unit?

Context is limited. A long tool stream about a small snag can push the actual work out of view. So can asking the human to host every local repair as a design discussion.

The unit gives that work a place to happen. Its tier sets the boundary. Its ledger keeps the history. Its digest and skim give the main seat a small return it can inspect.

This is a mid-session protocol. It is not an unattended improvement programme, a replacement for capturing durable principles, or a full design swarm. It should remove friction from the current task without quietly changing who has authority over the workspace.

The two pieces

The skill is a Markdown method: when to create a unit, its roles, tiers, denylist, caps and return format. It can be followed by a host that loads the files. Where independent agents are unavailable, the method has an honestly labelled serial fallback.

The optional api-improve CLI records the trail. The documented commands are classify, append, brief, skim, tail and trail. Its stated default is a local ledger and a local-or-none trail backend, with no forge credentials required for this release candidate.

  SKILL-ONLY (floor)              SKILL + CLI (optional clock)
  ------------------              ----------------------------
  drop skill into seat            pip install -e ".[dev]" from clone
  invoke on snag                  api-improve classify|append|...
  obey tiers / caps / denylist    ledger + trail on disk
  host must spawn or serial-fake  same doctrine, better audit surface

The old diagram calls the fallback “serial-fake”. Read that as one seat performing the stages in sequence, explicitly labelled serial_fallback. It must never be represented as independent peer work.

You still bring the host and its actual dispatch capabilities. The pack is not a complete nested-agent runtime.

The August account named a public GitLab repository as the source of the method, history and tags, but did not supply its URL. This page preserves that release history without inventing a current repository destination or a verified current CLI distribution.

Try one bounded snag

1. Choose how to load the method

The teaching here covers the protocol. The member kit is the convenience distribution: first-run path, seat-rule snippet, examples, scrubbed skill/prompts and tier card, all labelled 0.1.0-rc.1.

For skill-only use, copy or symlink the skill folder into the place your agent reads skills. Give it the snag in one line:

Run Agentic Progressive Improvement on this snag: <one line>.
Classify T0-T4. Prefer dispatch when multi-seat exists.
Use serial_fallback only if spawn is impossible. Obey denylist.
Re-enter with ↑ improve: when the tier requires it.

2. Use the optional ledger tooling if you have the source

The original setup sequence, from a checkout of that release, was:

pip install -e ".[dev]"
api-improve classify --snag "..." --path <path>
api-improve append --tier T1 --kind unblock --seat <id> --status building --snag "..."
api-improve skim --what "..." --tier T1 --ref <path> --undo "git revert HEAD"
api-improve tail -n 5
api-improve trail --backend local

The documented ledger default is the XDG state location under api-improve, overridden with API_IMPROVE_LEDGER. The trail backend is local or none. These are the release instructions, not commands run by this essay or a claim that an uninspected package has been verified.

The example undo command is a placeholder. The unit must retain an undo action that actually fits the change and its repository state.

3. Run the unit

  1. Classify: choose T0 to T4. Raise one tier if unsure.
  2. Record: append a building entry to the local ledger.
  3. Assign: brief the improve agent with the snag, tier, allowed paths, denylist and inherited model.
  4. Continue: keep the original task moving rather than filling the main window with the repair.
  5. Check the return: verify claims on disk when shipping matters, update the ledger and show the skim when the state change needs visibility.
  6. Escalate T3/T4: return needs-operator with the paths. Never promote silently. T4 prepares only; it does not mutate automatically.

Keep the tiers distinct

TierWorkVisibility and authority
T0Session hygieneLocal only; silent when green, with ledger and undo story
T1Task unblockBranch work; optional skim; auto-merge only within strict explicit caps
T2Tool inheritanceBatch at a pause; human merge
T3Method or rulesDraft until approved; ask before promotion
T4Red zoneAsk; prepare only, with no automatic mutation

Risk tier ladder from T0 session hygiene to T4 prepare only

The classification floors are part of the method:

  • Uncertainty raises the tier rather than lowering it.
  • Seat rules, methodology or durable process changes are at least T3.
  • Secrets, remotes, disk cleanup, sudo and public publication are T4.
  • A second occurrence of the same pain class may justify moving T1 work to T2, to consider a reusable tool.
  • A first, one-off snag usually stays a T1 unblock rather than becoming a permanent new tool.

The denylist categories are mass disk wipes, protected remotes, secret dumps, sudo without approval, public publication without scrub, pushing main and irreversible unattended actions. The kit and original SPEC contain the full text. A clean scrub does not grant publication authority; T4 still prepares and asks.

The improve agent uses the same model as the orchestration seat. Local mechanical builders are allowed only with headroom. The method does not switch cloud vendors merely to save cost.

Say how it actually ran

ModeWhat happenedWhat you can claim
dispatchThe host spawned separate seatsA peer improve unit
serial_fallbackOne seat performed the stagesThe method and digests, without independent peer review
partialA mixtureName which legs used which route

Dispatch is preferred when the host supports it. Serial execution is the portable fallback. A permission boundary or missing host capability is not something the written method can waive.

Pick the method that fits the work

                 +---------------------------+
                 | brainstorming swarm       |
                 | many seats on DESIGN      |
                 | stop at written spec      |
                 +------------+--------------+
                              |
           +------------------+------------------+
           |                                     |
           v                                     v
  +------------------+                  +------------------+
  | solo brainstorm  |                  | build swarm      |
  | one seat, design |                  | many seats on    |
  | until approval   |                  | IMPLEMENTATION   |
  +------------------+                  +------------------+

  orthogonal (this pack):
  +----------------------------------------------+
  | Agentic Progressive Improvement              |
  | mid-session SNAG → nested improve unit       |
  | desk/repo better · operator stays in chat    |
  +----------------------------------------------+

Sibling pack icons: solo lamp, design swarm field, progressive improve wrench

The icons illustrate different jobs. Use the stopping point to choose.

MethodJobStopping point
Solo brainstormOne seat works through a designWritten spec
Brainstorming swarmSeveral lenses test a designWritten spec, no implementation
Build swarmDivide agreed implementationReviewed, shipped units
Agentic Progressive ImprovementHandle a snag during another taskA checked improvement while the original conversation continues

Taste decisions belong with the operator. Durable principle capture belongs with the appropriate memory or codification process. An unsettled design needs design work, not a repair unit disguised as a design swarm.

Use this method when the real task is already running and a bounded snag should not take over the window.

Get the convenience kit

The versioned member zip packages the first-run path, seat snippets, examples, scrubbed skill copy and tier card. The teaching remains available here. The original account described the underlying method as open and MIT licensed; the convenience kit is the packaged starting point.

Blank sticky note doodle with a quiet stick figure for the membership note

[ comments ]

guests welcome. members show first in the list

members

  • Just amazing.

    member (Frontier) OG · Sat, 08 Aug 2026 19:22:47 GMT

1 / 12