Use it from a coding agent

One command installs the skill for Claude Code. Any other coding agent can read the same files, set up by hand. Either way, your agent can add Peal to an application without reading any of this first.

Install in Claude Code

One command, run in your project. It writes ten markdown files into .claude/skills/peal/, which is where Claude Code looks for skills. No package, no registry, no account.

curl -fsSL https://peal.network/skill/install.sh | sh

Then ask for what you want, in your own words:

use the peal skill to add sealed bid auctions to my marketplace
for the vintage camera listing, closing Monday at 6pm, reserve $50

Other coding agents

Cursor, Codex, Copilot and other agents do not read .claude/skills/, so the command above leaves files they will never open. The content is plain markdown, though, and works in any of them. Pick one of these:

  • Point it at the skill online. Tell the agent to read https://peal.network/skill/SKILL.md and follow it. The reference files it names sit beside it, at https://peal.network/skill/reference/….
  • Keep a copy in the project. Install into a folder of your choosing, then add one line to the agent's own instructions file (AGENTS.md, a Cursor rule, or whatever it reads): "For anything involving Peal, follow docs/peal/SKILL.md."
    curl -fsSL https://peal.network/skill/install.sh | PEAL_SKILL_DEST=docs/peal sh
  • Paste it. Paste the contents of SKILL.md into the chat, and the reference file for the task when the agent asks for it.

Then ask the same way as above.

What it does with that

The skill is a procedure, not a reference card. Given a sentence like the one above, the agent works through five steps, and the order matters because the shape of the integration depends on what is already in your codebase.

  1. Surveys your application first. Whether there is a server or only a front end, where listings live, how state is stored, where the buy button is, and how you already handle time. It tells you what it found before it writes anything.
  2. Pins the deadline. "Monday at 6pm" becomes an exact instant in your timezone, confirmed back to you in full before anything is created, because an auction that closes at the wrong hour cannot be undone.
  3. Chooses where the code runs. Bids are sealed in the browser, because a plaintext bid must never reach a server, including yours. Your server creates the auction and reads results.
  4. Writes it against your stack, from tested integrations for Next.js, Express, a static page, or a non-JavaScript backend.
  5. Verifies before reporting success. It runs curl -fsSL https://peal.network/skill/verify.sh | sh, which opens a real auction with a short deadline, bids on it, waits for it to open and checks the board. About a minute, and it reports success only when the check prints PASS.

More examples that work: "collect quotes from my suppliers privately until Friday" · "let people vote on this without seeing a running tally" · "my agents keep front running each other, seal their actions until the round ends".

And for private payments

Say "let customers pay my shop privately" or "add a payment link that keeps the amount off the chain" and the skill switches engines to Peal Private Links. The same discipline, a different path: it decides whether the account belongs to your business (one account in your server, your own encrypted store) or to each user (in their browser, their wallet), points the checkout at the hosted pay page rather than rebuilding it, writes the request and sync code from a tested recipe, and runs a verification script against the node that signs in, registers, creates a request and reads it back the way a payer would. It also carries the words it must not use: trustless, unlinkable, audited, mainnet.

If piping a script to a shell is not something you do, read install.sh first. It is a mkdir, one curl per file for the ten files, and an optional install counter you can switch off with PEAL_NO_COUNT=1; it writes nothing else and runs nothing else. Or copy the files yourself from /skill/SKILL.md.

Why a skill rather than documentation

An agent that has read a reference page can call the endpoints. That is not the hard part. The hard part is the handful of decisions that produce code which looks right and is wrong, and which no endpoint description would warn anybody about:

  • Money as a float instead of integer minor units, which is fine until an auction is large enough for the rounding to matter and there is no arguing with a number that came out wrong in public.
  • Sealing the digits of a bid without padding, which puts its magnitude on the wire. The ciphertext length ranks the whole auction for anyone watching, before a single bid opens.
  • Sending the seller's private contact key to the server, which would let us read every contact detail the scheme exists to protect.
  • Treating a slot count as a participant count, when batches are padded with decoys precisely so they are not the same number.
  • Handling the null that every v1 read returns before the deadline as an error, or as an empty result, when it is the guarantee working.

The skill leads with those, because an agent that gets them right the first time is the whole point of installing it.

What is inside

  • SKILL.md: the procedure above, the mistakes that produce code which looks right and is wrong, and the trust model stated plainly enough that an agent will not overclaim it to a user.
  • reference/recipes.md: working integrations for Next.js, Express, a static page and a non-JavaScript backend, including the one that catches everybody: a URL import of the client works in a browser and throws in Node.
  • reference/time.md: turning "Monday at 6pm" into an exact instant, with a timezone helper checked against daylight saving, a 45 minute offset and a negative one.
  • reference/verify.md: the end to end script, and what each failure means when it does not pass.
  • reference/api.md: every endpoint, its parameters and its responses.
  • reference/auctions.md: the money rules, contact details and the check code.
  • reference/errors.md: every error code and every limit, as tables.
  • reference/ui.md: matching the app's design system, and the states an interface for sealed submissions needs.
  • reference/payments.md: charging per call with x402, and copying the pattern into your own API.
  • reference/links.md: Peal Private Links: private payment links and transfers through the hosted app and the public /links/v1 reads, with the trust model an agent must not overstate.

Other tools

The files are plain markdown with YAML frontmatter, which is the Claude Code skill format; other agents ignore the frontmatter and read the rest, as "Other coding agents" above describes.

For a model with web access and no skill installed, llms.txt is the short version, written to be quoted.

An MCP server is on the roadmap, which is the other way an agent could reach this without any files at all.