Identity

Rent the intelligence. Own the work. (지능은 빌리고, 작업은 소유한다.)

Yardlet is a local console for engineering the loop that turns a few sentences of intent into verified, durable work — using your already-installed coding agents as interchangeable workers.

The four layers

1. Deterministic core, generative behind the contract. The orchestrator does only deterministic, auditable operations — compiling packets from state, routing by rules, evaluating by checks, merging by git, running hooks. Anything that generates or judges work goes through the worker contract: packet in → process → result files out. A Yardlet-shipped worker (a native API adapter, someday) is identity-compatible exactly when it sits behind that same contract, routable like any other worker.

2. Containerized work. The shipping container didn't make ships faster; it standardized the unit of cargo so that logistics became possible — any ship, any crane, any port. The packet/result contract is that container spec for delegated cognitive work. Routing, parallel worktrees, recovery, adoption, audit, handoff: all of Yardlet's features are the logistics that a standard unit makes possible. A yard is literally where containers wait, get inspected, and get assigned to carriers.

3. Verification is the scarce good. Worker capability churns — the best model changes every few months, and Yardlet gets stronger when workers improve, because its product is not generation. As generation gets cheap, the binding constraint becomes: can you trust, verify, and account for what an agent did while you weren't looking? The evaluator, the gates (ambiguity, approval, hooks), human promotion, and the audit trail are not safety chrome. They are the product.

4. User-owned, compounding capital. Work done in a chat session belongs to no one — it evaporates. Yardlet keeps the records, rules, skills, telemetry, and handoffs in .agents/, in your repo, in open formats, portable across workers. That asset appreciates: telemetry improves routing, handoffs become organizational memory, promoted lessons strengthen every future packet. Capability depreciates; accountability compounds. Yardlet sits on the compounding side.

The moment this lands in: loop engineering

In mid-2026 the discourse caught up with the shape of this product. Boris Cherny (Anthropic, Claude Code lead): "I don't prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops." Addy Osmani then named the practice loop engineering: "you stop being the person who prompts the agent and start being the person who designs the system that prompts it" — spec → execute → verify → iterate, with the verifier deliberately separated from the doer.

Yardlet is that practice as a product, with one addition the vendor loop primitives (claude /loop//goal, codex Automations) don't give you: the loop is yours. It is worker-neutral (any CLI behind one contract), local (state in your repo, not a vendor session), verified by parties other than the doer (deterministic evaluator + reviewer-role tasks), and it compounds (every cycle can strengthen the harness all future cycles ride). Vendor loops run inside one vendor's walls; Yardlet is the loop you own across all of them.

The practice this enables

• You don't write prompts — packets are compiled. Intent contract + rules + skill catalog + role discipline + checkpoint are the source; every worker prompt is a build artifact. Improving the loop's inputs improves every future prompt without anyone writing one.
• You don't babysit sessions — you engineer the loop. What enters the context (harness), what blocks passage (gates), what survives a cycle (checkpoints), what compounds across cycles (learning loop): those are the knobs. The loop runs rented labor; you own the loop.

One-line forms

• Tagline: Rent the intelligence. Own the work.
• Mechanism: Prompts are compiled, not written.
• Positioning: Workers race on capability; Yardlet races on nothing-gets-lost.
• Metaphor: The container yard for AI labor.

What this rules out

No magic keywords or hidden modes (contracts are explicit artifacts). No worker-grade tool surfaces in the core (owning them pulls the console into the judgment loop). The harness self-improves — skills and learned rules are written and pruned automatically — but the deterministic core is the sole writer (workers propose, Yardlet records) and an eval loop self-corrects, so the human steps back instead of approving each change; gates are reserved for the irreversible or outward-facing (push, deploy, secrets). No vendor lock-in of the user's capital (open formats, read-only discovery of existing assets). See absorption.md for the full invariants.