Ari’s Space*   est. 2026
Skip to content
ari*s space[ a. ]
← Librarydispatch / 2026-07-06

Stop handing context to your agents. Pack it.

Pack exact IDs, paths and values verbatim, condense the rest, and verify what the dispatched workers actually did.

4 parts / Hover to explore. Click to read.

Pack exact IDs, paths and values verbatim, condense the rest, and verify what the dispatched workers actually did.

Task context
  +-> exact needles --+
  +-> condensed gist -+
  +-> re-fetch refs --+
                      v
                 Context Pack
                      |
                   worker
                      |
                inspect output
Copy details that cannot tolerate approximation; condense the surrounding material and keep retrieval references. A worker's success count does not replace inspecting its work.
A plan comes in. It leaves as finished work, each piece routed to the cheapest model that can do it.

A worker needs enough context to do its job. Hand it the entire history and it can spend the turn reading. Hand it a vague summary and the exact ID you needed can become an educated guess.

I use a Context Pack to make that handoff deliberate: one text file, with the details that must survive copied exactly and the surrounding material condensed.

Keep the needles exact

A needle is a detail where an approximation would break the work: an ID, a path, a value or a line that defines the contract. Keep those verbatim. Summarise the bulk and leave references the worker can fetch when it needs more.

One file. The needles stay exact. Everything else is gist you can re-fetch.

For this workflow I sized the pack to half the receiving model's context window. That was the working budget, leaving room for the task and its result. It wasn't an invitation to fill half a window with everything available.

needle extractor
1 / 3
what the pack keeps
Deploy commit 7f3a9c2e1b8d to the box.
Config lives at /etc/app/config.yaml, port 8080.
NEVER push to the remote before the gate passes.
The rest is background: we tried a few approaches
last week and settled on the simple one, which reads
fine and does not need to be exact to be useful.
4 needles kept verbatim. The rest greys to gist you re-fetch.
Type anything. The exact needles stay sharp, the bulk fades to gist.

Route the packed job

The manager chooses the cheapest Claude tier that can handle the task. Small jobs go straight to a worker. Larger ones fan out under a cheaper model with a large context window, which brings the results back together.

Complexity picks the model. No point burning the big one when the small one does the job.

The setup described in this July 2026 build used subscription access rather than metered API calls. Treat that as the billing arrangement for the reported build, not a promise of unlimited usage or current plan terms.

Check what actually ran

I used the tool to ship its own repository by pointing it at itself. It reported “12 ok”. I then diffed every file before trusting it.

A previous workflow had already told me “ok” about work it never ran. Once you've seen that, a tidy tally loses some of its charm.

The check is the changed file and the behaviour it produces. The count is a clue to inspect, not the evidence that finishes the job.

The project is MIT-licensed and was built with Claude: PUSHINGSQUARES/Build. Start with one bounded task, make its pack, and compare the returned work with the original requirement.

↓The /swarm skill (Build), ready to drop into your Claude Code

[ comments ]

guests welcome. members show first in the list

no comments yet. start the thread_

1 / 6