vikhyath-thelazycoder/agylite

Agylite is a local engineering OS for coding agents. It bundles the best parts of 15 open-source agent projects (ECC, gstack, Graphify, UI/UX Pro Max, Open Design, Karpathy Skills and more) into one plugin and one CLI. Each request loads only the few capabilities it needs, the agent follows one planned lifecycle, and work counts as done only when local tests, types and builds pass and the evidence is recorded.

Quick start

1. Add the plugin (in Claude Code)

/plugin marketplace add Vikhyath-thelazycoder/AgyLite
/plugin install agylite@agylite-marketplace

2. Install the engine (once, in a terminal)

curl -fsSL https://raw.githubusercontent.com/Vikhyath-thelazycoder/AgyLite/main/install.sh | bash

This needs macOS or Linux, git and Python 3.10 or newer (on macOS: brew install python@3.12). It downloads the 15 pinned upstream projects once (about 2 minutes), builds the capability bundle in ~/.agylite, and puts agylite on your PATH. After that Agylite works offline. You never clone the upstream projects yourself.

Optional: turn on auto-update. In Claude Code run /plugin, open Marketplaces → agylite-marketplace and enable auto-update (or add "autoUpdate": true to its entry under extraKnownMarketplaces in ~/.claude/settings.json). Claude Code then updates the plugin by itself, and the plugin brings the engine in ~/.agylite up to the same version in the background at the next session start.

3. Start a new session and work as usual. Ask for something like "Build a small Python CLI todo app with tests": the agent routes the request, writes a plan task, implements it test-first and verifies it before calling it done. Run agylite doctor at any time to check the install.

Other hosts

agylite adapters status shows each host as FILES_PRESENT, INSTALLED or RUNTIME_VERIFIED (only after the host has actually run Agylite).

Why Agylite

Installing agent plugins one by one loads every plugin's descriptions on every turn and leaves the model to guess which one applies. Agylite routes deterministically and loads sections on demand.

Measured with agylite benchmark --compare on the development machine; tokens are bytes ÷ 4 estimates. Full results.

How it works

flowchart LR
    R["Your request"] --> RT["Route<br/>deterministic rules"]
    RT --> C["Context<br/>only the routed sections"]
    C --> U["Understand<br/>questions · impact"]
    U --> P["Plan<br/>one living plan"]
    P --> I["Implement<br/>test-first"]
    I --> V["Verify<br/>local tests, evidence"]
    V --> RC["Reconcile<br/>task → VERIFIED"]

• Route. agylite route matches the request against rules and capability tags. "Fix the payment webhook security" gets security, impact analysis and security tests; "make a launch video" gets the video workflow and nothing else.
• Context. agylite context loads short capability cards first and the relevant skill sections only when needed, within a token budget.
• Plan. Every project has one plan (docs/IMPLEMENTATION_PLAN.md). Blocking requirement questions must be answered before a task starts, and task status rolls up into its phase.
• Verify. agylite verify runs the tests, type checks, lint and build that the change reaches, and records machine-readable evidence. Browser and screenshot "verification" is turned off by policy.
• Watch it. agylite dashboard --open shows the Agent Office: one agent per capability, lighting up as it works.
• See what was used. Every answer ends with agylite used: the routed capabilities, the upstream projects whose guidance was loaded (ECC, gstack, UI/UX Pro Max, …) and the engines that ran.

What's inside

63 capabilities in 7 domains, each with recorded provenance (upstream, commit, path, hash, license):

Commands

agylite route "Fix the payment webhook security." --brief   # what this request needs
agylite context engineering/security testing/security        # load just that guidance
agylite codebase affected                                    # files and tests the current change reaches
agylite verify                                               # run the impacted checks, record evidence
agylite dashboard --open                                     # the Agent Office
agylite used                                                 # what this session used: capabilities, upstreams, engines

All commands

Staying current

Upstreams are pinned, never pulled blindly. agylite update --check lists new upstream commits, agylite update --latest applies them through every check and switches only when all pass, and agylite rollback undoes it. A GitHub Action checks daily and opens a weekly pull request with checked updates.

Principles

• Light. A few short entry skills on every turn; everything else is routed and loaded in budgeted sections.
• Deterministic. Routing is rules, not a model call.
• Local and test-first. Done means recorded evidence from tests, types, lint and build.
• Nothing always-on. No daemons and no MCP servers; engines start per command in isolated environments.
• Traceable. Every bundled file records where it came from and under which license.

Built on

Agylite stands on the work of these projects. Their content keeps its original license; see THIRD_PARTY_NOTICES.md.

FAQ

Do I need to install ECC, UI/UX Pro Max or the other projects separately?

No. The installer fetches the parts Agylite uses at pinned commits and builds them into one local bundle. If you already have some of them installed as separate plugins, agylite doctor shows how many tokens they add per turn, so you can decide whether to remove them.

Is the plugin alone enough?

The plugin is the host integration; the engine is installed once with the one-line installer above. Without the engine, the plugin tells you how to finish setup at session start instead of failing.

Does my code leave my machine?

No. Routing, context, planning, verification and the dashboard run locally. The network is used to fetch upstreams during install or update, and by SEO commands you run against a live site.

Does it use MCP servers or browser automation?

No MCP servers. Browser, Chrome DevTools and screenshot verification are disabled by policy; work is verified with local tests (policy).

How do I update or uninstall?

With auto-update on, nothing: the plugin updates itself and refreshes the engine at session start. Otherwise run /plugin update agylite@agylite-marketplace; the engine follows at the next session start (or run the installer again). agylite update --latest brings in newer upstream commits. To uninstall: /plugin uninstall agylite@agylite-marketplace, then rm -rf ~/.agylite and remove the # Agylite PATH line from your shell profile.

Documentation

• Architecture and the component docs in docs/architecture/
• Try it on a real build: a hands-on trial an agent runs and reports on
• Benchmarks · Changelog · Migrating from v1

Contributing

git clone https://github.com/Vikhyath-thelazycoder/AgyLite.git && cd AgyLite
python3 -m venv .venv && .venv/bin/pip install -e .
.venv/bin/python -m unittest discover -s tests
.venv/bin/agylite doctor && .venv/bin/agylite validate

See CONTRIBUTING.md and the Code of Conduct. Security issues: SECURITY.md.

License

Agylite is MIT licensed. Bundled upstream files keep their own licenses (13 MIT, 2 Apache-2.0).