Macrokit

Live · Apache 2.0 · Open source

Weak and local LLMs that work like frontier models — on narrow workflows.

Macrokit is an open-source SDK — and an open format for macros, the deterministic, distilled workflows a weak or local model can run — for shipping LLM applications under cloud-API constraints: data residency, compliance, air-gapped networks, or budget.

View on GitHub Try the live demo → How it works

Live demo · preview

See it run — Macrokit Studio

A self-distilling workspace for GitHub maintainer tasks that runs entirely in your browser. A small local model (WebLLM, via WebGPU) routes your request to pre-authored macros — no API key, no server, nothing leaves your machine. Watch the graduation counter climb as more of your session is served locally at $0.

Open Macrokit Studio → How it works

Public repos only · reads + dry-run writes · a strong model authors the macros at design time, the local model routes at runtime.

The pattern, in 60 seconds

The hard part for weak models is multi-step reasoning. The easy part is routing. Macrokit pushes the hard part offline so cheap and local models can do the routing reliably.

It’s how brains manage the cost of thinking, ported to LLM systems: a slow, expensive deliberation path (System 2 — the strong model) compiles repeated reasoning into a fast, cheap automatic path (System 1 — the macro). A fast cheap reflex and a slow expensive mind, with the reflex carrying the load.

1

Design-time

A strong model (Claude, GPT-4o) solves a workflow once, supervised by a developer, and encodes it as a deterministic, parameterized macro.

2

Runtime

A weak or local model receives a user request and only has to do intent classification — one-shot routing — to the matching macro.

3

Distillation gate

Every session that touched a workflow without a macro must encode one before ending. macrokit gate enforces it. The macro library compounds — the artificial version of neural chunking: deliberation compiled into reflex through repetition.

What you get

  • @macrokit/runtime — macro registry, dispatcher, session log, intent router.
  • @macrokit/llm — one transport for OpenAI-compatible providers (OpenAI, DeepSeek, Qwen, OpenRouter, …), Ollama, and Anthropic; bail-out detector that catches weak-model failure modes before they reach your app.
  • @macrokit/browser — Playwright service with annotated screenshots and DOM action menus. Weak models pick numbered elements instead of estimating coordinates.
  • @macrokit/authoring — defineMacro(), schema helpers, a test harness with recording mode.
  • macrokit CLI — init, lint, and the headline gate command that enforces the distillation discipline.

How it differs

Not an agent framework.
Agent frameworks compete on letting LLMs reason. Macrokit competes by eliminating runtime reasoning. Different philosophy.
Not a skills or prompt format.
A skill tells a strong model how to think. A macro is the compiled, deterministic result of that thinking — it runs on weak and local models with no reasoning at runtime. Macros can call MCP tools as primitives; Macrokit sits above MCP, not against it.
Not a model.
BYO-model. Ships adapters for OpenAI-compatible APIs and Ollama out of the box.
Not RPA.
RPA records UI clicks at the pixel level. Macros are recorded at the semantic level — typed tool calls with named arguments — and are diff-reviewable code.
Not a no-code platform.
Authoring a macro assumes a developer plus a strong model in the loop. End users see only the chat interface.

Benchmark

On a pre-registered 100-task maintainer-agent corpus, the production on-device model from one Macrokit deployment — Qwen 2.5 7B Q4_K_M, running locally on a 16 GB MacBook — scored:

94.5% intent-routing accuracy  ·  0/100 bail-outs  ·  5.85 s mean latency

We deliberately did not run cloud-API rows ourselves. The harness ships open; run it on whatever keys you have, against any OpenAI-compatible, Anthropic, or Ollama endpoint. The whole point of Macrokit is that frontier-API access shouldn’t be the benchmark.

Read the benchmark methodology & full results →

Status

Live and open (Apache 2.0), running today. The pattern Macrokit codifies has been running in a private production deployment since early 2026. Macrokit is the vertical-agnostic extraction of that work into a reusable SDK.

The docs site, quickstart, API reference, and reference implementation land at launch. Until then this page is the canonical pointer.

Where it’s headed: the macros authors build are the point. Macrokit ships a community registry for sharing and discovering vertical macro libraries — the seed of an ecosystem where adopting a new vertical can start from proven macros instead of a cold start.

Build on top

Macrokit keeps core/examples/ small. Vertical macro libraries live as standalone npm packages you publish yourself — named macrokit-macros-<vertical>, tagged with the macrokit-macros GitHub topic, and (optionally) listed in the community registry for discoverability. The contributor surface is intentionally large; the curated surface is intentionally small.

Run macrokit lint --pkg <path> against your package to check it against the conformance bar before opening a listing PR. The same checks reviewers run.