Raphael AI

Raphael AI is Raphael's open-source collection of agent plugins, reusable skills, reference material, and evaluation cases. It helps developers plan and build Raphael integrations while preserving the verification and transaction-safety boundaries described throughout these docs.

Raphael AI is guidance for compatible coding agents. It is not a hosted trading agent, wallet, signer, source of private deployment data, or substitute for independent review.

What is included

The repository publishes four plugins containing nine focused skills:

Plugin	Skills	Use it for
raphael-deployer	deployer, launchpad-graduation	Planning, rehearsing, deploying, and verifying contracts; moving completed bonding curves into canonical Raphael liquidity
raphael-trading	swap-integration, liquidity-integration, aggregator-integration, pay-with-any-token	Building swaps, LP and gauge workflows, DEX aggregator support, and supported payment-token conversion
raphael-viem	viem-integration	Typed Robinhood Chain and Raphael interactions using viem and wagmi
raphael-driver	swap-planner, liquidity-planner	Preparing non-custodial swap or liquidity plans without signing or submitting transactions

Skills contain concise instructions and load detailed references only when needed. Evaluation cases test important failure behavior, such as missing deployments, stale indexers, token-order errors, price conflicts, and unsupported payment challenges.

Install

Skills CLI

Install all Raphael skills in an agent that supports the open Skills format:

npx skills add raphaelexchange/raphael-ai

Claude Code

Add the repository marketplace, then install the plugin needed for your work:

/plugin marketplace add raphaelexchange/raphael-ai
/plugin install raphael-trading

The available Claude Code plugins are raphael-deployer, raphael-trading, raphael-viem, and raphael-driver.

Codex

The repository includes Codex plugin manifests for the same four plugins. Install the relevant plugin from the included marketplace when your Codex client supports repository marketplaces. If it does not, use the Skills CLI command above to install the skills directly.

Installing a plugin supplies instructions and reference material. It does not grant wallet access, provide a private key, or authorize transaction submission.

Choose a workflow

Goal	Skill
Prepare or verify a contract deployment	deployer
Design a bonding-curve graduation	launchpad-graduation
Add safe swap execution to an application	swap-integration
Build basic or concentrated LP and gauge flows	liquidity-integration
Add Raphael liquidity to a DEX aggregator	aggregator-integration
Convert a chosen token for a supported payment challenge	pay-with-any-token
Configure typed viem or wagmi clients	viem-integration
Prepare a swap without executing it	swap-planner
Plan a liquidity position or price range	liquidity-planner

Ask the agent for the outcome in ordinary language, or name the skill explicitly when the client supports direct skill invocation. Provide the repository and application context needed for the task, but never provide a seed phrase or private key.

Safety model

Every Raphael AI workflow follows the same core rules:

1. Verify Raphael-specific sources. Deployment manifests, contract source, ABIs, pool provenance, chain state, and ownership must be pinned or independently verified.
2. Never substitute upstream configuration. Familiar interfaces do not make another protocol's addresses, constants, route flags, or ABIs valid for Raphael.
3. Fail closed when inputs are missing. A skill may design or scaffold an integration with explicit placeholders, but it must not present an unverified transaction as executable.
4. Keep arithmetic exact. Contract amounts, limits, slippage calculations, ticks, and receipts use integer base units rather than floating-point arithmetic.
5. Simulate before writes. The exact sender, target, value, calldata, approvals, limits, deadline, and chain must be simulated before submission.
6. Require human confirmation. Signing and submission remain behind explicit confirmation. A successful simulation is preparation, not consent.
7. Report confirmed outcomes. A quote or transaction hash is not a completed trade. Execution results come from successful receipts and decoded events.

These controls reduce avoidable mistakes, but generated plans and code can still be incomplete, outdated, or wrong. Review the repository's usage disclaimer before relying on an agent-assisted workflow.

Deployment data and executable work

Raphael AI treats Contract Deployments as the public registry for verified addresses and versions. The mainnet Genesis release is published there. When a required component or ABI is not part of that release, a skill can:

• design an integration and its safety boundaries;
• scaffold typed configuration with explicit missing values;
• implement validation, simulation, receipt handling, and tests; and
• identify the exact deployment evidence needed to proceed.

It must not invent an address, ABI, pool, gauge, route, quote, reward rate, or executable transaction. Integrations using the published release should pin its addresses, revisions, and ABIs, then validate them against onchain bytecode before enabling writes.

LLM context

The repository also publishes two generated context files for tools that consume project documentation directly:

• llms.txt is the concise plugin and source index.
• llms-full.txt contains the complete generated skill and reference context.

These files provide machine-readable guidance, not live chain state. Applications must still use current verified deployments and onchain reads for transaction-critical decisions.

Contribute and verify

Raphael AI is released under the MIT License. Contributions should add evaluation coverage for material workflow or safety changes and keep transaction execution behind simulation and explicit confirmation.

From a local checkout, validate all plugin manifests, skills, references, evaluation coverage, and generated LLM context with:

npm run validate

See the Raphael AI repository for source, contribution guidance, plugin manifests, and evaluation cases.