Loadout Context Engine
Automatically equips coding agents with the right context and workflow for each stack, machine, or task.
Per-dimension scores and reasoning
The README says Loadout writes local gitignored overlays, avoids shared instruction files, binds its UI to localhost, stages diffs, and uses atomic writes, environment allowlists, secret-name denial, token redaction, script trust, dry runs, doctor, and clean. The npm workflow also checks that a non-interactive invocation refuses a silent installation. This supports reasonably strong privilege control, confirmation, effect disclosure, and recovery. Points are withheld because security.md, the installer, synchronization, updater, and implementation are absent, so network destinations, command isolation, secret-detection coverage, and every write path cannot be checked. Curl-to-shell installation, dynamic shell fragments, automatic config pulls, and self-update expand the execution and supply-chain surface. Cargo dependencies use broad version requirements and Actions use mutable major-version tags; no dependency audit, artifact checksum, or release-signing evidence is supplied. Authorship, repository ownership, MIT copyright, and the inspirations for bundled workflows receive basic attribution, but per-item provenance and licenses for vendored material are not shown.
The README, Cargo manifest, and CI are broadly consistent about the Rust CLI, command name, platforms, and test entry points. CI covers formatting, Clippy, Linux/macOS tests, a browser smoke test, and the declared minimum Rust version. The command catalog, doctor, explain, and the npm refusal check show attention to diagnosable failures. Deductions reflect the absence of implementation, lockfile, and test bodies, which prevents static confirmation of dependency availability and message quality. Cargo comments say some studio dependencies are for capabilities to be wired in later slices while the README presents those capabilities as current, creating a modest consistency concern. Windows requires WSL, while git, browsers, and external agent executables remain explicit but externally supplied dependencies.
The material thoroughly identifies scenarios across Rust, Node, Next.js, Go, Python and other stacks, repo-less machine work, five named agents, CLI/VS Code usage, global/project configuration, and customizable workflows. Deterministic target matching, exactly-one selection, a remembered prompt for ambiguous matches, and default-or-empty behavior give trigger selection unusually precise documentation. Deductions apply because boundaries around dynamic shell providers are not fully developed in the supplied files, workflows are guidance rather than enforced policy, and generic integration is manual. Native support is limited to macOS/Linux, Windows depends on WSL, and some agent integrations require global hooks, environment variables, or local wiring files.
The README has strong information architecture spanning quick start, model, workflows, support matrix, storage, commands, safety, installation, and documentation. Installation channels, source builds, updates, and platform requirements are concrete, and examples are extensive. The complete MIT text matches Cargo metadata, justifying full license credit. Deductions reflect necessary but cognitively costly naming differences between load and loadout, colon and dash commands, and agent-specific filenames; limitations are distributed rather than consolidated. Cargo declares 0.28.0 and README links releases, but no changelog, version policy, or migration policy is included. Maintenance responsibility can only be inferred from the Ellery Familia copyright, package scope, and repository URL; no maintainer roster, support policy, or security-reporting route is shown. Unknown publisher identity is not treated as suspicious.
The outputs are directly consumable agent overlay files, augmented by explain, preview, plan HTML, structured feedback, and cross-agent workflow commands, making the product's intended results highly usable. Separating personal context from repository instructions, automatic stack selection, and consistent workflows across agents offer credible incremental value over a single static instruction file. Deductions apply because the value and cost claims rest chiefly on README descriptions rather than supplied implementation or comparative evidence. Users must maintain global TOML, trust dynamic scripts, accommodate agent-specific wiring, and accept complexity from git synchronization, self-updating, and several generated files.
Most product claims are tied to named commands, concrete paths, configuration examples, selection rules, and CI jobs. Cargo metadata corroborates the README's product identity and license, while the npm workflow corroborates the stated consent behavior. Deductions reflect the absence of core source, Cargo.lock, linked security/concepts documents, test bodies, release configuration, and installer code, leaving security controls, determinism, byte-identical rendering, automatic wiring, and synchronization untraceable to implementation. The documentation often distinguishes guidance from enforcement, but strong statements such as “never touched,” byte identity, and exclusive official channels lack independent corroboration in the supplied material.
- Installation can execute a remote shell script from the latest GitHub release; pin a version and verify the installer plus artifact checksums or signatures before adoption.
- Dynamic fragments may execute shell commands, while synchronization and self-update contact external sources; review security.md and the implementation, and tightly scope trusted scripts and sync repositories.
- Cargo.lock, core source, and test bodies were not supplied, so dependency resolution, safety controls, agent wiring, and rollback behavior cannot be confirmed from this static review.
- Different agents require changes in different local or global wiring locations; inspect the exact write plan with dry-run and load explain, and retain backups before first use.
- Publisher identity is unknown. This is not evidence of malice, but an organization should independently establish maintenance, security-reporting, and release-key responsibility.
What does this agent do, and when should you use it?
Loadout is a Rust-based local CLI and context engine that selects and generates instructions for different coding situations. Users maintain reusable fragments, named loadouts composed from those fragments, and optional six-stage workflows in global TOML configuration. When `load claude`, `load codex`, or another supported launcher runs, Loadout detects the current repository or machine context, selects exactly one loadout, and renders an overlay into agent-specific, gitignored files. It directly supports Claude, Codex, Cursor, opencode, and Copilot, with an emit-only generic target; selection is deterministic and does not ask an LLM to choose. The repository also provides the localhost `load studio` editor, Git-based configuration sync, diagnostics and script-trust controls, plus a deterministic renderer for reviewing structured development plans as self-contained HTML. Its deployment boundary is the developer's machine: global configuration lives under `~/.config/loadout`, while bindings, logs, caches, and generated instructions remain local to each repository.
Loadout reads fragments, loadouts, targets, and workflows from ~/.config/loadout/config.toml, along with unsynced machine-specific values from local.toml. load <agent> detects Rust, Node, Bun, Next.js, Go, Python, Java, Ruby, PHP, Swift, .NET, or a repository-free machine context; when several loadouts match, it asks once and records the project's choice. It evaluates static fragments, built-in providers, or approved shell commands, renders the selected fragment list, and connects the result through each product's supported local mechanism. Codex receives .loadout/generated/agents.md merged into AGENTS.override.md; Claude uses .loadout/generated/claude.md imported by CLAUDE.local.md; Cursor reads .cursor/rules/loadout.mdc; Copilot uses a gitignored VS Code instructions file or a CLI custom-instructions environment variable; opencode receives global instructions. load studio visually edits the TOML model and stages a reviewable diff, while load explain, refresh, clean, detect, doctor, and trust expose selection, regeneration, cleanup, diagnostics, and script approval. For plan review, load plan check validates an agent-written plan.json, and load plan render produces a byte-deterministic, self-contained plan.html with comments anchored to tasks, phases, risks, and open questions.
- A developer moving among Rust, Next.js, and Python repositories who wants coding conventions, preferred commands, and communication style to switch automatically with the stack.
- An engineer who alternates between Claude Code, Codex, Cursor, opencode, and Copilot and wants one personal context library instead of maintaining separate instruction sets.
- A systems or DevOps practitioner working on bare servers outside repositories who needs a machine loadout for host-specific operating guidance.
- A user with an existing global
CLAUDE.mdorAGENTS.mdwho wantsloadout-migrateto convert it into reusable fragments without changing the original. - A team member following Superpowers, Spec Kit, Kiro, or Every compound-engineering practices who wants the process exposed through one explore-to-ship command spine.
- A technical lead who wants to inspect an implementation plan in a browser, comment on individual tasks and risks, and return structured feedback to the coding agent.
What are this agent's strengths and limitations?
- One fragment and loadout library feeds five explicitly supported coding products, plus a generic emit-only output, reducing duplicated personal instructions.
- Selection is deterministic and visible through
load explain; ambiguous matches prompt once and are remembered for the project instead of being delegated to a model. - It preserves shared repository policy by writing only local, gitignored overlays, bindings, and managed blocks rather than editing committed instruction files.
- Dynamic context supports both built-in providers and approved shell output, with an environment-variable allowlist, secret-name denial, token redaction, atomic writes, and trust checks.
- The package covers authoring, migration, synchronization, diagnostics, workflow delivery, and deterministic browser-based plan review rather than only concatenating prompt files.
- Only one loadout can be active for a context; loadouts do not stack, so every desired fragment must be composed inside the selected loadout.
- Rendered overlays are advisory instructions, not enforced runtime policy, so Loadout cannot guarantee that an agent follows them.
- Official prebuilt support is limited to macOS and Linux, with Windows routed through WSL, and the project explicitly provides no official Homebrew tap.
- Delivery details vary by product: Cursor and VS Code expose workflow commands with dashes while other integrations use colon-style names, adding cross-client conventions to learn.
- Git is required for cross-machine sync, and shell-backed fragments add approval, re-trust, and local security-management overhead.
How do you install or deploy this agent?
For the official prebuilt installer on macOS or Linux—using WSL on Windows—run:
curl -LsSf https://github.com/elleryfamilia/loadout/releases/latest/download/loadout-installer.sh | shWith Node.js available, the consent-based npm bootstrapper can install the CLI and open the studio:
npx @ellery/loadout studioTo build from source, use:
cargo install --git https://github.com/elleryfamilia/loadoutLoadout itself does not document any required API credentials. The binary and npm installation paths require network access; a source install requires Rust and Cargo. Git is additionally required for configuration sync, and minimal Linux images may need apt install git first.
How do you use this agent?
Start with load studio, choose the recommended starter pack, review the staged changes, and apply them. Alternatively, edit ~/.config/loadout/config.toml directly: define a fragment with guidance, then reference its ID from a loadout with targets such as targets = ["rust"]. Run load explain to inspect the detected context, selected loadout, active fragments, and planned file writes. Then launch an installed coding product with load claude, load codex, load cursor, load opencode, or load run copilot. Use load use <loadout> to pin a project, load refresh --agent all to regenerate overlays without launching anything, and load doctor to check configuration and safety issues. For multi-machine use, run load sync init or load sync init <git-url> on a system with Git, followed by load sync clone <git-url> elsewhere.
How does this agent compare with similar options?
Compared with copying personal preferences into every repository's AGENTS.md, CLAUDE.md, or shared Copilot instructions, Loadout keeps personal context globally and selects it by stack, machine, or project before writing a local gitignored overlay. Project instruction files describe the repository; Loadout is intended for the conventions, tools, and working style a developer carries between repositories. Its workflow layer can model Superpowers, Spec Kit/Kiro, or Every's compound-engineering process behind a common six-stage command spine, but those workflows remain rendered guidance rather than a separate execution engine.
FAQ
Does Loadout require an API key or paid model service?
Will it overwrite the team's committed instruction files?
AGENTS.md, CLAUDE.md, and .github/copilot-instructions.md, using AGENTS.override.md, CLAUDE.local.md, .loadout/, and other gitignored paths instead.What happens when several loadouts match the same project?
What safeguards exist for shell-generated fragments?
--dry-run. The resulting overlay is still guidance rather than an enforceable security boundary.Can configuration be shared without synchronizing private host details?
load sync init and load sync clone use Git to share the global configuration, while hostnames, host classes, and machine-specific values remain in a private local.toml that is not synchronized.