lap

Lean API Platform

Agent-Native API specs. Verified, compressed, ready to install.

Website · Registry · Benchmarks · Docs

Request a Spec · Report a Bug · Request a Feature

---

Without API documentation, LLM agents hallucinate endpoints, invent parameters, and guess auth flows -- scoring just 0.399 accuracy in blind tests.

LAP fixes this. One command gives your agent a verified, agent-native API spec -- jumping accuracy to 0.860. And because LAP specs are up to 10x smaller than raw OpenAPI, you also save 35% on cost and run 29% faster.

Not minification -- a purpose-built compiler with its own grammar.

Proven in 500 blind runs across 50 APIs

LAP Lean scored 0.851 (vs 0.825 raw) while using 35% less cost and 29% less time -- same accuracy, far fewer tokens.

Full benchmark report (500 runs, 50 specs, 5 formats) · Benchmark methodology and data

Quick Start

# Set up LAP in your IDE
npx @lap-platform/lapsh init                    # Claude Code
npx @lap-platform/lapsh init --target cursor    # Cursor
npx @lap-platform/lapsh init --target codex     # Codex

# Search the registry for an API
npx @lap-platform/lapsh search payment

# Download a spec
npx @lap-platform/lapsh get stripe -o stripe.lap


# Install an API skill
npx @lap-platform/lapsh skill-install stripe

# Or compile your own spec
npx @lap-platform/lapsh compile api.yaml --lean

Use as an Agent Skill

Install the LAP skill so your agent can search, compile, and manage APIs automatically:

Claude Code:

npx @lap-platform/lapsh init

Cursor:

npx @lap-platform/lapsh init --target cursor

Codex (CLI & VS Code extension):

npx @lap-platform/lapsh init --target codex

Codex agents use curl for registry operations (search, get, check) instead of npx -- instant in the sandbox. Skills install to ~/.codex/skills/. Auto-update hooks are pre-configured for when Codex enables its hooks engine (codex_hooks feature flag is currently experimental).

OpenClaw: install from ClawHub or copy manually:

cp -r skills/lap ~/.openclaw/skills/lap

Once installed, agents auto-trigger the skill when working with APIs -- or invoke it directly with /lap. You can also install individual API skills for specific integrations:

npx @lap-platform/lapsh skill-install stripe
# Agent now knows the full Stripe API

Want to get listed? Register as a verified publisher and share your specs and skills with the registry.

# Install globally (npm or pip)
npm install -g @lap-platform/lapsh
pip install lapsh

What You Get

• 📦 Registry — browse and install 1500+ pre-compiled specs at lap.sh
• 🗜️ 5.2× median compression on OpenAPI, up to 39.6× on large specs — 35% cheaper, 29% faster (benchmarks)
• 📐 Typed contracts — enum(a|b|c), str(uuid), int=10 prevent agent hallucination
• 🔌 6 input formats — OpenAPI, GraphQL, AsyncAPI, Protobuf, Postman, Smithy
• 🎯 Zero information loss — every endpoint, param, and type constraint preserved
• 🔁 Round-trip — convert back to OpenAPI with lapsh convert
• 🤖 Skill generation — lapsh skill creates agent-ready skills from any spec
• 🔗 Integrations — LangChain, Context Hub, Python/TypeScript SDKs

How It Works

Five compression stages, each targeting a different source of token waste:

Stage	What it does	Savings
Structural removal	Strip YAML scaffolding — paths:, requestBody:, schema: wrappers vanish	~30%
Directive grammar	@directives replace nested structures with flat, single-line declarations	~25%
Type compression	type: string, format: uuid → str(uuid)	~10%
Redundancy elimination	Shared fields extracted once via @common_fields and @type	~20%
Lean mode	Strip descriptions — LLMs infer meaning from well-named parameters	~15%

Benchmarks

1,500+ specs · 5,228 endpoints · 4.37M → 423K tokens

Format	Specs	Median	Best
OpenAPI	30	5.2×	39.6×
Postman	36	4.1×	24.9×
Protobuf	35	1.5×	60.1×
AsyncAPI	31	1.4×	39.1×
GraphQL	30	1.3×	40.9×

Verbose formats compress most — they carry the most structural overhead. Already-concise formats like GraphQL still benefit from type deduplication.

The Ecosystem

LAP is more than a compiler:

Component	What	Command
Init	Set up LAP in your IDE	lapsh init --target claude
Search	Find APIs in the registry	lapsh search payment
Get	Download a spec by name	lapsh get stripe
Skill Install	Install an API skill	lapsh skill-install stripe --target claude
Skill Uninstall	Remove an installed skill	lapsh skill-uninstall stripe
Uninstall	Fully remove LAP from your IDE	lapsh uninstall --target claude
Check	Check installed skills for updates	lapsh check [--target claude|cursor|codex]
Diff	Compare installed skill vs registry	lapsh diff stripe
Pin / Unpin	Skip or resume update checks	lapsh pin stripe
Compiler	Any spec → .lap	lapsh compile api.yaml
Skill Generator	Create agent-ready skills from any spec	lapsh skill api.yaml --install
API Differ	Detect breaking API changes	lapsh diff old.lap new.lap
Round-trip	Convert LAP back to OpenAPI	lapsh convert api.lap -f openapi
Publish	Share specs to the registry	lapsh publish api.yaml --provider acme

Claude Code, Cursor & Codex: The lap skill is included -- run lapsh init and your agent can search, install, and manage API skills directly. Claude Code and Cursor support auto-update checks via SessionStart hooks. Codex hooks are pre-configured and will activate when the codex_hooks feature becomes stable.

Supported Formats

lapsh compile  api.yaml           # OpenAPI 3.x / Swagger
lapsh compile  schema.graphql     # GraphQL SDL
lapsh compile  events.yaml        # AsyncAPI
lapsh compile  service.proto      # Protobuf / gRPC
lapsh compile  collection.json    # Postman v2.1
lapsh compile  model.smithy       # AWS Smithy

Format is auto-detected. Override with -f openapi|graphql|asyncapi|protobuf|postman|smithy.

Top Compressions

Integrations

# LangChain
from lap.middleware import LAPDocLoader
docs = LAPDocLoader("stripe.lap").load()

LangChain, Context Hub, and Python/TypeScript SDKs. See integration docs.

FAQ

Because they have no way to find the spec, and even if they could, it's a million tokens of YAML written for humans. Agents without specs score 0.399 accuracy -- wrong 60% of the time. They hallucinate endpoint paths, send invalid types, and miss auth. Give them a LAP spec and accuracy jumps to 0.860. The spec doesn't make the agent smarter. It makes guessing unnecessary.

LAP doesn't replace OpenAPI — it compiles FROM it. Like TypeScript → JavaScript: you keep your OpenAPI specs, your existing tooling, everything. LAP adds a compilation step for the LLM runtime.

MCP defines how agents discover and invoke tools (the plumbing). LAP compresses the documentation those tools expose (the payload). They're complementary — LAP can compress MCP tool schemas.

Minification removes whitespace — that's ~10% savings. LAP performs semantic compression: flattening nested structures, deduplicating schemas, compressing type declarations, and stripping structural overhead. That's 5-40× savings. Different class of tool.