---
title: "Build with agents"
description: "Point your coding agent at the Wavelength docs and let it do the integration work, with installable skills, markdown mirrors, and ready-made prompts."
canonical: https://wavelength.lightning.engineering/agents/
---

> Docs index: https://wavelength.lightning.engineering/llms.txt

# Build with agents

Your coding agent can do most of a Wavelength SDK integration for you. This page wires it up: installable skills that teach the agent our APIs and conventions, machine-readable docs it can fetch efficiently, and prompts that kick off the work.

## Install the skills

The fastest setup. One command installs four Wavelength skills into every agent the [skills CLI](https://skills.sh) supports (Claude Code, Cursor, Codex, Copilot, Gemini CLI, and more):

```sh
npx skills add lightninglabs/wavelength-sdk
```

- **wavelength-web**: embedding the wallet in a browser or React web app.
- **wavelength-react-native**: embedding the wallet in a React Native or Expo app.
- **wavelength-api**: integrating against the wallet daemon’s gRPC or REST API.
- **wavelength-cli**: automating wallet operations with the CLI.

Claude Code users can install through the plugin marketplace instead:

```sh
/plugin marketplace add lightninglabs/wavelength-sdk
```

The same catalog is served from this site, so `npx skills add wavelength.lightning.engineering` also works.

## Machine-readable docs

- [llms.txt](/llms.txt): an index of every page, with descriptions, in the llms.txt convention.
- [llms-full.txt](/llms-full.txt): the entire docs corpus in one file.
- Every page on this site has a markdown twin: append `.md` to any URL. Agents get the same content as the HTML at a fraction of the tokens.

## Add the Wavelength SDK to your AGENTS.md

Paste this into your repo’s `AGENTS.md` (or `CLAUDE.md`); your agent then carries the ground rules in every session:

```markdown
<!-- BEGIN: wavelength-agent-rules -->
## Wavelength SDK

The Wavelength SDK embeds a self-custodial Lightning wallet in this app: Lightning
payments with no node, channels, or liquidity to manage.

- Packages: @lightninglabs/wavelength-web (browser transport, has
  createWebWalletEngine), @lightninglabs/wavelength-react-native (React Native
  transport, has createNativeWalletEngine, daemon compiled into the app
  binary), @lightninglabs/wavelength-react (provider and hooks, takes an
  injected engine), @lightninglabs/wavelength-core (shared contract).
- Docs: https://wavelength.lightning.engineering/llms.txt. Every docs page has
  a markdown twin at the same URL with .md appended; fetch those.
- Web: create the engine with createWebWalletEngine() and inject it via
  <WavelengthProvider engine={...}>. Never import wavelength-web from
  framework-agnostic code.
- React Native: create the engine with createNativeWalletEngine() and
  inject it via <WavelengthProvider engine={...}> the same way.
- Self-host the wasm runtime assets and set runtimeBaseUrl; see
  https://wavelength.lightning.engineering/web/get-started/hosting-runtime-assets.md
- Check npm for current package versions instead of memorized ones.
<!-- END: wavelength-agent-rules -->
```

## Kick-off prompts

```text
Integrate the Wavelength SDK into this app so users get an embedded
self-custodial Lightning wallet.

1. Read https://wavelength.lightning.engineering/web/get-started/quickstart.md
   and https://wavelength.lightning.engineering/integrations/react.md first.
2. Install @lightninglabs/wavelength-web and @lightninglabs/wavelength-react at
   their current npm versions.
3. Copy the wasm runtime assets into our static assets and configure
   runtimeBaseUrl per
   https://wavelength.lightning.engineering/web/get-started/hosting-runtime-assets.md
4. Create the engine with createWebWalletEngine() and mount <WavelengthProvider
   engine={...}> at the app root. Do not import wavelength-web anywhere
   except where the engine is created.
5. Add a minimal wallet screen: create or unlock, balance, receive invoice,
   send payment.
6. Verify: the app builds, wallet creation reaches the ready state, an
   invoice renders, and the wallet unlocks after a page reload.
```

```text
Integrate the Wavelength SDK into this React Native app so users get an
embedded self-custodial Lightning wallet.

1. Read https://wavelength.lightning.engineering/react-native/get-started/quickstart.md
   first.
2. Install @lightninglabs/wavelength-react-native and
   @lightninglabs/wavelength-react at their current npm versions.
3. Stage the native wallet runtime binaries before the first build per
   https://wavelength.lightning.engineering/react-native/get-started/installation.md
4. Create the engine with createNativeWalletEngine() and mount
   <WavelengthProvider engine={...}> at the app root. Do not construct the
   engine outside the provider's module scope.
5. Add a minimal wallet screen: create or unlock, balance, receive invoice,
   send payment.
6. Verify: the app builds and launches on a device or simulator through a
   development build (not Expo Go), wallet creation reaches the ready
   state, and an invoice renders.
```

```text
Integrate this backend with the Wavelength wallet daemon over its API.

1. Read https://wavelength.lightning.engineering/api/get-started.md and
   https://wavelength.lightning.engineering/api/rest.md first.
2. Decide gRPC or REST for our use case and say why.
3. For each operation we need, fetch the RPC's page from the API section of
   https://wavelength.lightning.engineering/llms.txt and use its exact request
   and response fields; do not guess field names from other Lightning tools.
4. Implement connection setup including TLS and auth exactly as the
   get-started page describes.
5. Verify: a getinfo-style call succeeds and one end-to-end operation
   round-trips against a dev daemon.
```

```text
Write automation for the Wavelength wallet using wavecli.

1. Read https://wavelength.lightning.engineering/cli.md first: global flags,
   JSON output mode, and exit codes.
2. Use JSON output for all parsing; never scrape table output.
3. For each command you use, read its page (for example
   https://wavelength.lightning.engineering/cli/send.md) and handle the
   documented exit codes.
4. Verify: run the script against a dev daemon and show the output.
```

## MCP

We do not run a hosted docs MCP server. If your workflow expects one, any llms.txt-compatible docs server works against this site, for example [mcpdoc](https://github.com/langchain-ai/mcpdoc) pointed at `https://wavelength.lightning.engineering/llms.txt`. Most agents get further with the skills plus the markdown mirrors above. Integrators running the wallet daemon themselves can also run [`wavecli mcp serve`](https://wavelength.lightning.engineering/cli/mcp.md) to start a local MCP server exposing each daemon RPC as a typed tool call.

> **Repository access**
>
> The GitHub install commands go live when the repository is public at launch. Until then, use the docs-domain install.