The bAInquet AI Skill

Skills are how AI agents integrate with bAInquet. The bainquet-pipeline Agent Skill is the primary, cross-agent way to turn any website or project into a verified, structured, AI-optimized Knowledge Node — without a prebuilt connector. Install it once and it works across Claude Code, Cursor, Codex, Windsurf, and the 70+ other agents the skills CLI supports.

A Skill is a portable instruction set (a SKILL.md with a name and description) that a skill-aware agent loads on demand. The bAInquet Skill is provider-neutral: everything it does is plain HTTP and standard cryptography, so any agent in any language can run it. The agent does the integration; bAInquet does the extraction, structuring, and publishing.

Minimum agent capability

The skill runs shell commands or code, makes outbound HTTPS requests, and reads your project files. Any agent that can do those works (Claude Code, Cursor, Codex, Windsurf, Continue, and the rest). A chat-only assistant with no code execution or network access cannot run it.

Install

The recommended installer is the open-source skills CLI. It auto-detects the AI agents you already have installed and wires the skill into each of them — no need to say which one:

npx skills add radioBros/bainquet-skills

By default this installs into the current project (./.claude/skills/, ./.cursor/skills/, ./.codex/skills/, …). To install for all your projects (your user directory), add -g:

npx skills add radioBros/bainquet-skills -g

If no agents are detected, the CLI prompts you to pick which ones to install to. To target a specific agent explicitly, pass -a:

npx skills add radioBros/bainquet-skills -a claude-code

How the installer works

npx skills add reads the public radioBros/bainquet-skills repo, then creates the skill in each detected agent's skills directory (it symlinks to a single canonical copy by default; pass --copy to copy files instead). Manage installed skills with npx skills list and npx skills update.

Manual install (no CLI)

Copy the bainquet-pipeline skill directory into a standard skills location for your agent:

• Claude Code: ~/.claude/skills/bainquet-pipeline/ (personal) or .claude/skills/bainquet-pipeline/ (project-local)
• Other agents: that agent's skills directory, e.g. ~/.cursor/skills/, .codex/skills/, .windsurf/skills/ — see your agent's docs for the exact path.

Copy the whole folder — it ships bainquet-scaffold.md (the full contract, offline) and bainquet-sign.py (a tested reference signer) alongside SKILL.md.

How to invoke

Once installed, your agent loads and suggests the skill based on its description when you ask to publish or sync a project. Exactly how it triggers depends on the agent — some load it automatically from the description, others let you select or @-mention it. Natural prompts that surface it:

• "Publish this project to bAInquet."
• "Sync this site's content to bAInquet."
• "Connect this repo to bAInquet for AI consumption."

Provide the three values it needs as environment variables, never pasted into chat:

export BAINQUET_CONNECTOR_TOKEN="connectorId.secret"
export BAINQUET_WEBSITE_ID="site_xyz"
export BAINQUET_SITE_DOMAIN="example.com"

What it does

The skill's job is narrow and deterministic: discover content, map it to ingestion items, sign requests correctly, and post them. bAInquet does all extraction and publishing downstream. It walks these steps:

1. Read the contract from the bundled offline scaffold or the live manifest (it never hardcodes the contract).
2. Obtain a connector token (an existing token, or one issued from the dashboard for a verified website).
3. Discover the project's content units (content directories, a product catalog, a docs tree, a sitemap).
4. Map each unit to an IngestItem with a stable sha256: checksum.
5. Sign each batch with the bq.connector.hmac.v1 scheme and POST to /v1/ingest/batch.
6. Read the per-item results, re-send only failed items, and retry only 5xx / 429.
7. Advertise custom attributes via /v1/ingest/schema when needed.
8. Set up incremental sync with a persisted cursor and heartbeats.

For JavaScript and TypeScript projects it uses @bainquet/connector-sdk; for any other language it implements the raw recipe (Python 3.11 stdlib hmac and hashlib work with no dependencies).

The gates

The skill respects two non-negotiable gates throughout:

• Ingest only when verified or in grace. Ingest is allowed only when the website's verification state is verified or grace; otherwise the server returns 409 website.not_verified and the skill pauses until the domain verifies.
• Never publish on an unverified domain. A node never becomes public until the domain is verified.

WARNING

Token safety is non-negotiable. The skill reads the secret only from an environment variable and never prints, logs, echoes, or writes it to any file or to the repository. If a step would expose the secret, the skill stops and asks you to set the env var instead.

Under the hood: the contract it targets

The skill does not redefine the ingestion contract — it reads it each run, so it stays correct as the contract evolves. The same portable artifacts are available to any agent or hand-built integration:

• Offline scaffold (bainquet-scaffold.md) — a single self-contained Markdown recipe with the embedded JSON contract, the exact HMAC signing recipe, field tables, and error/retry guidance. Ships inside the skill so it works air-gapped.
• Reference signer (bainquet-sign.py) — a stdlib-only signer with a built-in known-answer test, also bundled. python3 bainquet-sign.py --selftest confirms an agent's signing reproduces the exact bytes the server expects, before any request is sent — the highest-leverage safeguard against 401 auth.invalid_signature.
• Online machine-readable bundle — the live truth an agent fetches to self-configure against the current, versioned contract.

See Universal AI artifacts for the scaffold and the online bundle in full, and Ingestion and signing for the endpoint and HMAC reference.

Reference

The skill reads the contract from one of these each run, rather than memorizing it:

• Offline scaffold (full contract and HMAC recipe): bainquet-scaffold.md (bundled with the skill).
• Online manifest: https://api.bainquet.online/.well-known/bainquet/manifest.json.
• OpenAPI: https://api.bainquet.online/scaffold/openapi.json.
• JSON Schema: https://api.bainquet.online/scaffold/schema/ingest-item.json.
• Worked examples: https://api.bainquet.online/scaffold/examples/.