Repotoire vs ESLint
ESLint is the industry-standard linter for JavaScript and TypeScript. Repotoire is a local agent-processor runtime for explicit development workflows. They solve different problems and can coexist in a serious engineering workflow.
Feature Comparison
| Feature | Repotoire | ESLint |
|---|---|---|
| Execution model | agent-processor runtime for development work | Per-file rule-based linting |
| Runtime state | .machine state, events, evidence, and traps | No persistent workflow state |
| Work contract | Machine programs with explicit opcodes | Rules configured in eslint.config.js |
| Cross-worker coordination | Scoreboard hazards and write claims | No worker coordination model |
| Verification | Evidence packets and gate verdicts | Rule pass/fail results |
| Provider adapters | Codex, Claude, MCP, local runners | Editor and build integrations |
| Retirement | Verified retirement gate | Deterministic --fix for rules |
| Precise traps | Stops stale or unsafe writeback | Not a workflow runtime |
| Code style / formatting | No (not a formatter) | Yes (with stylistic plugins) |
| CI/CD integration | Explicit CLI reports and team-approved gates | Universal (any CI, formatters, SARIF via plugin) |
| Pricing | Commercial private beta | Free and open source |
Different Tools, Different Jobs
ESLint operates per-file. It parses each JavaScript or TypeScript file individually, applies rules to the AST, and reports violations. It's excellent at catching code style issues, potential bugs, unused variables, and enforcing team conventions. With its plugin ecosystem, you can add React hooks rules, accessibility checks, import ordering, and thousands of other checks.
Repotoire operates as a local Machine. It records explicit program state, worker packets, evidence, write claims, verification gates, and precise traps. These are workflow semantics that per-file linting does not try to provide.
What ESLint Catches That Repotoire Doesn't
- •Code style and formatting (semicolons, indentation, naming conventions)
- •Framework-specific rules (React hooks order, Vue template syntax, accessibility)
- •Import ordering and organization
- •Deterministic auto-fix for hundreds of rules
- •Highly customizable per-rule configuration
What Repotoire Adds to an Agent Workflow
- ✓Repository context from parsed symbols, imports, and relationships
- ✓Symbol impact queries to inspect possible dependents before an edit
- ✓Explicit uncertainty when parser coverage or dependency evidence is incomplete
- ✓Machine reports for inspecting recorded execution state and evidence
- ✓Verification gates defined by the approved work contract
- ✓Explicit source writeback and retirement records
- ✓Parser-backed context for TypeScript, JavaScript, Rust, and Python
Using Both Together
Repotoire and ESLint are complementary tools. A recommended setup for JavaScript/TypeScript projects:
Structural evidence helps plan an investigation; it does not prove a defect or a safe deletion. A Machine report reads recorded evidence. It does not run linting or enforce an architecture threshold.
ESLint (on every save)
Code style, per-file bugs, React hooks rules, import ordering, accessibility. Runs in your editor with instant feedback.
Repotoire (runtime gate)
Machine state, evidence packets, verification gates, worker hazards, and explicit writeback. Runs when agent work needs an inspectable contract.
# Separate linting from inspecting an existing Machine run - name: Lint (ESLint) run: npx eslint . - name: Inspect recorded Machine evidence (Repotoire) run: repotoire machine report . --format json
Setup
Repotoire
# Access is provided during private beta onboarding # Inspect a repository with an existing Machine run repotoire machine report .
Beta onboarding maps the runtime to your repo, policy gates, and adapter trust model.
ESLint
# Install npm init @eslint/config@latest # Lint npx eslint .
Requires a config file. Highly configurable with plugins, presets, and overrides.
Verdict
This isn't an either/or choice. ESLint is the best tool for JavaScript/TypeScript per-file linting — it has an unmatched plugin ecosystem and deep framework integration. Repotoire is the runtime for making agent-driven repo changes explicit and inspectable.
Use ESLint to keep individual files clean. Use Repotoire when work needs machine state, evidence, gates, traps, and explicit writeback.
Give agent work a runtime
Keep ESLint for linting and use Repotoire when repo-changing work needs machine programs, source-pipeline evidence, precise traps, and MCP adapters.
repotoire machine report .