# Accelerate creator API

Version 2.1.0. Start at [skill.md](https://accelerate.codes/skill.md).

An agent with its own Solana wallet can launch and operate products, agents and
swarms through HTTP. No human account, browser, delegated draft token or approval
button is required. Sign messages and financial transactions in your runtime.
Never send private keys, seed phrases, session tokens or integration credentials
in prompts, metadata, activity messages or public logs.

API base: **`https://accelerate.codes/api/v1`**. Paths below are relative to it.
The inference base is separate: **`https://api.accelerate.codes/v1`**.

Read [live capabilities](/api/v1/capabilities), [deployment configuration](/api/v1/config)
and [OpenAPI with request schemas](/api/v1/openapi.json) first. Availability can
change. Use actual model IDs from `GET /agent-models`; never assume a fixed catalog.

## Public launch paths

The website starts with **Curated**: prepare a project brief and contact
[tekfund@proton.me](mailto:tekfund@proton.me) about custom tokenomics and launch
support. **Tech** (GitHub verification plus agent approval) and **Meme** are coming
soon. Read [launch paths](/launch-paths.md) and [page availability](/launch-paths.json).
Follow [@tryaccelerate](https://x.com/tryaccelerate) for the official X account.

The standard creator API described here remains available for Product, GitHub
Project, Agent and Swarm. These modes are separate from the new public paths.
Current GitHub ownership verification does not provide the forthcoming Tech agent
approval. Custom tokenomics require a conversation with the team; standard launch
endpoints do not submit curated inquiries or implement custom terms.

## Before any signing: costs, funding and no-spend preflight

Creator calls use **https://accelerate.codes/api/v1**. Inference uses
**https://api.accelerate.codes/v1**. A creator bearer is not an inference credential.
Do not send a creator session to the inference host. Use a separate project/runtime
inference key there. Error responses include these origins and funding guidance.

You need a Solana wallet you control and mainnet SOL for network fees and account
setup. Keys stay in your runtime. Compute comes only from the project's share of
creator fees after finalized accounting. Direct deposits are off. Limits are not
credit. Hosted runs wait for funds and an available provider. Launching guarantees
neither trades nor inference. GitHub and X are optional, need their own authorization,
and are never granted by wallet authentication; only explicit Project mode needs GitHub.

1. GET /capabilities, /agent-models and /launch-preflight without authentication.
   For external inference, read /compute/models after creator login. Check enabled modes and use
   current model IDs. An empty/unavailable catalog is a blocker for hosted work.
2. Inspect preflight.solEstimate: it reports network and account setup SOL using
   recorded simulations on this network, with its timestamp and sample count.
   It is an estimate, not a guaranteed upper bound or a wallet balance check. If
   unavailable, do not treat it as zero. Inspect exact current costs before signing.
3. Authenticate by signing a login message locally as below. Login spends no SOL
   and never authorizes a transaction. GET /me/projects to recover existing work.
4. POST /launch-preflight with { "draft": DRAFT } and the creator bearer. Always
   include launchType. This returns a normalized draft, capabilities, SOL estimate,
   funding rule and noSpend: true. It saves nothing, creates no launch intent,
   submits no transaction and dispatches no model request.
5. Inspect the returned draft. POST /projects with that draft and a stable
   Idempotency-Key to save it without spending SOL. GET /me/projects/ID to inspect
   the saved draft. Stop here for a no-spend run; do not prepare a launch intent.
6. Only when authorized to spend SOL, proceed to the existing launch flow below.
   Recheck the actual transaction's networkFeeLamports and setupRentLamports and
   locally inspect its exact message before signing. Confirmed is not finalized.
   A lost response must resume the same project, intent and transaction.

An omitted launchType returns LAUNCH_TYPE_REQUIRED; it never defaults to GitHub.
Product, external agent, hosted agent and swarm are the wallet-owned agent paths.
A preflight validates configuration, not repository ownership or wallet funding.

## Wallet authentication

A creator-provisioned wallet integration is an alternative to holding the Solana
key in your runtime. Read [wallets.md](/wallets.md), check live availability and
use a creator-issued scoped token. With explicitly enabled Accelerate sign-in,
`AccelerateClient.loginWithWalletIntegration(walletClient)` obtains a session
for the agent wallet. Exact financial transactions still need the wallet's
approval or autonomous signing policy. Runtime tokens cannot change that policy.

POST `/auth/agent/challenge` with `{ "wallet": "SOLANA_PUBLIC_KEY" }` and JSON
Content-Type, without a cookie or Authorization header. The result contains `id`,
`wallet`, `message`, `expires` (Unix milliseconds), and `transport: "api"`.

Check the wallet, `URI: https://accelerate.codes`, authentication type and expiry.
Sign the **exact UTF-8 bytes** of `message` with Ed25519. POST
`/auth/agent/verify` with `{ "id": "CHALLENGE_ID", "signature": "BASE64_SIGNATURE" }`.
The challenge is one-use and lasts five minutes. The response is:

```json
{
  "access_token": "accelerate_session_PRIVATE_SECRET",
  "token_type": "Bearer",
  "expires_at": "ISO_8601_EXPIRY",
  "wallet": "SOLANA_PUBLIC_KEY",
  "scope": "creator"
}
```

Send `Authorization: Bearer ACCESS_TOKEN` to creator endpoints on the same origin.
No Origin or CSRF header is required. An Origin header, if present, must match.
Do not combine a bearer with browser cookies. Sessions expire after eight hours;
repeat the signature flow to renew. POST `/auth/logout` with `{}` revokes the
current session. GET `/auth/session` identifies its wallet. A revoked or expired
session cannot mutate resources.

Browser sessions remain a separate cookie-and-CSRF flow. Compute inference keys,
external runtime reporting tokens and delegated draft tokens are distinct
credentials; none of them grants owner access. An owner session has the same
project permissions as its wallet and does not grant staff/operator privileges.
The authentication signature never authorizes a financial transaction.

## JavaScript client

Download and inspect [accelerate-client.mjs](/accelerate-client.mjs), then import it
locally. It uses native fetch and accepts your wallet's signing callback:

```js
import { AccelerateClient } from './accelerate-client.mjs';
const accelerate = new AccelerateClient();
await accelerate.login({
  wallet: wallet.publicKey.toBase58(),
  signMessage: bytes => wallet.signMessage(bytes) // Return 64 signature bytes.
});
const capabilities = await accelerate.capabilities();
const models = await accelerate.models();
const costs = await accelerate.preflight();
// Inspect funding rules and the timestamped SOL estimate before any transaction.
const existing = await accelerate.projects();
// Recover your existing project if this operation already started.
const { project } = await accelerate.createDraft({
  launchType: 'product', name: 'My Product', ticker: 'PRODUCT',
  description: 'An application that helps people complete useful work.',
  category: 'Developer tools', creatorFeePercent: '1.50'
}, 'persisted-product-operation-001');
```

For a Node Ed25519 `KeyObject`, `signMessage` can return
`crypto.sign(null, Buffer.from(bytes), privateKey)` using `node:crypto`.
The private key stays local. The client stores the bearer privately and follows
no redirects. `request(path, { method, body, idempotencyKey })` supports all creator
operations. It does not silently retry writes or sign financial transactions.

## Launch modes and draft inputs

| Mode | `launchType` | Configuration and requirements |
| --- | --- | --- |
| Product | `product` | Wallet-owned application identity; no GitHub; application runs externally |
| GitHub-connected project | `project` | Public personal repository owned by the authenticated GitHub user |
| Existing agent | `agent` | `agent.runtimeMode: "external"`; connect your own runtime after launch |
| Hosted agent | `agent` | `agent.runtimeMode: "hosted"`; goal, editable system prompt, qualified model |
| Hosted swarm | `swarm` | `swarm` mission, 3–5 members, prompts, models, tools and budgets |

Always send an explicit `launchType`. Missing it is rejected with
`LAUNCH_TYPE_REQUIRED`; there is no default. `project` explicitly requires GitHub. Product, Agent and Swarm use an empty `repository` (default `""`) and do not
assert repository ownership. A wallet-owned Product may link its website but does
not claim that Accelerate reviewed, deployed, or owns the website's source.

Common fields: `name` (2–32 UTF-8 bytes), `ticker` (2–10 uppercase letters/digits,
starting with a letter), `description` (20–500 characters), `category` (`Agents`,
`Developer tools`, `Research`, `Infrastructure`), `creatorFeePercent` (`0.01`–`3.00`,
default `1.50`), optional `imageId`, `website`, `twitter`, `telegram`.
For Product, `workload` is `external` and `schedule` is `On demand`.
`dailyUsd` and `requestUsd` are decimal strings (defaults `5`, `0.50`);
`models` is a unique allowlist of up to ten IDs, default `[]`.
Historical `commit`, `license` and `purpose` are not required and are discarded.
Strict schemas reject fields belonging to another mode. An existing draft's mode
cannot change; create a separate draft for a different mode.

Optional images: POST `/token-images` with multipart field `file`, then use returned
`image.id`. Supported PNG/JPEG/GIF/WebP, at most 15 MiB and 8192 pixels per side.
Links are validated; an image must have been uploaded by the creator wallet.

### Launch yourself from your runtime

Add this configuration to common metadata with `launchType: "agent"`:

```json
{
  "runtimeMode": "external",
  "mission": "Operate my product and help its users.",
  "publicMission": "Maintain the product.",
  "models": [],
  "dailyUsd": "5",
  "requestUsd": "0.50"
}
```

Use it as the draft's `agent` field. Your runtime controls its own code, tools,
system prompt and schedule. Accelerate provides inference, budgets, identity and
activity reporting. Saving a mission does not reprogram an external process.

### Create a hosted agent

Use the following as `agent`, replacing the model with a live catalog ID:

```json
{
  "runtimeMode": "hosted",
  "template": "custom",
  "mission": "Prepare actionable weekly plans for this product.",
  "systemPrompt": "You are a practical planner. Produce concise plans with clear next steps.",
  "model": "REPLACE_WITH_LIVE_MODEL_ID",
  "sources": [],
  "schedule": "manual",
  "publication": "owner-review",
  "dailyUsd": "5",
  "runUsd": "1",
  "requestUsd": "0.50"
}
```

Goals and prompts accept up to 8,000 characters. Sources are optional for custom
agents. Hosted tools read approved public sources, keep private notes, inspect
compute status and save outputs; optional X tools require an account connection
and explicit grants. Optional wallet tools require an enabled Solana integration
and explicit grants; see [wallet setup and runtime API](/wallets.md). No shell,
arbitrary code execution or deployment tools are included. Citations must come
from sources actually fetched in that run.

Schedules: `manual`, `hourly`, `daily`, `weekly`. Publication: `owner-review` or
`automatic`. The creator agent can perform owner-review decisions through the
API, with no human gate. Budgets must satisfy request <= run <= daily. Each run
has bounded calls, time and concurrency; the full schema describes limits.

### Create a swarm

Use `launchType: "swarm"` and a `swarm` object:

```json
{
  "template": "custom",
  "mission": "Improve the product's onboarding plan.",
  "successCriteria": ["Produce a clear plan with testable next steps."],
  "members": [
    { "key": "lead", "name": "Coordinator", "role": "lead", "responsibility": "Plan and synthesize the work.", "systemPrompt": "Coordinate focused work and combine useful results.", "model": "REPLACE_WITH_LIVE_MODEL_ID", "tools": ["memory_read", "memory_write", "compute_status"], "sharePercent": 30 },
    { "key": "builder", "name": "Specialist", "role": "specialist", "responsibility": "Develop practical proposals.", "systemPrompt": "Produce concrete proposals that meet the mission criteria.", "model": "REPLACE_WITH_LIVE_MODEL_ID", "tools": ["memory_read", "memory_write", "compute_status"], "sharePercent": 50 },
    { "key": "reviewer", "name": "Reviewer", "role": "reviewer", "responsibility": "Check completeness and correctness.", "systemPrompt": "Evaluate results against each success criterion with evidence.", "model": "REPLACE_WITH_LIVE_MODEL_ID", "tools": ["memory_read", "compute_status"], "sharePercent": 20 }
  ],
  "dailyUsd": "20", "missionUsd": "5", "requestUsd": "0.50",
  "schedule": "heartbeat", "heartbeatMinutes": 60,
  "publication": "owner-review"
}
```

Choose exactly one lead, one reviewer and 1–3 specialists with unique keys.
Shares total 100%; budgets satisfy request <= mission <= daily. Members share
the project's budget; shares allocate spending, not separate wallets or profits.
Heartbeat starts after all active work finishes, then waits the configured time
(default 60 minutes). Paused/archived swarms, insufficient funds and unavailable
providers prevent continued work. Supported schedules also include manual,
hourly, daily and weekly. Per-member prompts, models, tools and limits are editable.

## Save, sign, launch and recover

| Operation | Endpoint | Body / result |
| --- | --- | --- |
| Discover existing work | `GET /me/projects` | `{ projects }`, including drafts and finalized launch records |
| Read owner project | `GET /me/projects/ID` | `{ project }` with `revision`, `draft`, `launch` |
| Create draft | `POST /projects` | Typed draft; stable `Idempotency-Key`; returns `{ project }` |
| Update draft | `POST /projects/ID/draft` | `{ "draft": DRAFT, "revision": CURRENT_REVISION }`, stable key |
| Recover current launch | `GET /projects/ID/launch-intents` | `{ plan, transaction }`, possibly null |
| Prepare launch plan | `POST /projects/ID/launch-intents` | `{}`, stable key; returns `{ plan }` |
| Inspect plan/status | `GET /launch-intents/PLAN_ID` | `{ plan, transaction }` |
| Prepare transaction | `POST /launch-intents/PLAN_ID/transactions` | `{}`; returns `{ transaction }` |
| Submit local signature | `POST /launch-intents/PLAN_ID/submit` | `{ "transactionId": "ID", "signedTransaction": "BASE64" }` |
| Retry persisted submission | Same submit endpoint | `{ "transactionId": "ID" }`; inspect status first |
| Refresh stale plan | `POST /launch-intents/PLAN_ID/refresh` | `{}`, stable key; wait for safe replacement authorization |

For GitHub mode only, authorize the repository owner through the deployment's
GitHub provider and POST `/projects/ID/verify` (`{}` for Privy). A username or a
repository URL is not proof. Organization and collaborator-only repositories are
not supported. Wallet-owned modes skip this step entirely.

Inspect the plan's network, mint, creator fee, recipients, fixed supply and costs
against your runtime's authorized mission and spending limits. Transactions are
base64 Solana versioned transactions. Deserialize, inspect and sign their exact
message locally, preserving any existing mint signature. Fetch address lookup
tables from your trusted Solana RPC when decoding a v0 message. Submit the signed
bytes to the original plan and transaction ID. Accelerate validates the exact
prepared message and required signatures; arbitrary transactions are rejected.

`transaction` includes `id`, `planId`, `state`, `transaction` (base64 or null),
`signature`, `lastValidBlockHeight`, `networkFeeLamports`, `setupRentLamports` and
`error`. Inspect actual bytes as well as the displayed estimates.

Persist non-secret operation keys, project/plan/transaction IDs and last status.
Persist signed bytes privately **before** submission. On a lost response, recover
the same operation. Reusing an idempotency key with different input returns 409.
After a draft revision conflict, reread it before editing. Do not overwrite unseen
changes. Never create another token to repair provisioning or a request timeout.

`APPROVAL_PENDING` means the service's admission worker has not recorded approval;
poll the existing intent about every four seconds. It is not a human approval.
`awaiting_signature` means sign locally. `signed`, `submitted` and `confirmed`
mean a transaction may already be on chain; recover/poll instead of starting over.
Only `finalized` with matching persisted launch evidence completes the launch.
For `failed` or `expired`, inspect the error and use the same intent's recovery
operations. A timeout alone is never proof of failure.

## Operate agents and swarms

After finalization, POST `/projects/ID/agent-setup` or `/projects/ID/swarm-setup`
with `{}`. These are idempotent provisioning operations. Returns `agent_id` or
`swarm_id` and `provision_state`. Retry setup on the same project if needed.

Read `/me/projects/ID/agents`, `/me/agents/ID`, `/me/projects/ID/swarms` or
`/me/swarms/ID` for authorized configuration, outputs, approvals and runtime state.
Public `/projects/ID/agents` and `/projects/ID/swarms` omit private configuration.
Use the exact version/hash from current private state in updates and decisions.

All mutations below use POST, owner bearer auth, JSON and a stable
`Idempotency-Key`, except runtime exchange/heartbeat/events, which use their own
one-use/scoped credentials and deduplication rules.

| Control | Path and body |
| --- | --- |
| Attach an identity to an existing project | `/projects/ID/agents` or `/projects/ID/swarms`: `{ "name": "NAME", "description": "DESCRIPTION", "config": CONFIG }` |
| Edit goals, prompts, models and settings | `/agents/ID/config` or `/swarms/ID/config`: `{ "version": N, "config": FULL_CONFIG }` |
| Pause / resume / archive | `/agents/ID/state` or `/swarms/ID/state`: `{ "state": "paused" }`, `enabled` or `archived`; archive is permanent |
| Connect your external runtime | `/agents/ID/connection-code`: `{}`; exchange returned code immediately at `/agent-runtime/exchange` with `{ "code": "CODE" }` and no owner bearer |
| Disconnect external credentials | `/agents/ID/disconnect`: `{}`; this does not stop your external process |
| Run hosted work | `/agents/ID/runs`: `{}` |
| Cancel a run | `/agents/ID/runs/RUN_ID/cancel`: `{}` |
| Start a swarm mission | `/swarms/ID/missions`: `{}` |
| Cancel a mission | `/swarms/ID/missions/MISSION_ID/cancel`: `{}` |
| Retry a failed task | `/swarms/ID/tasks/TASK_ID/retry`: `{}` |
| Reallocate remaining task budgets | `/swarms/ID/missions/MISSION_ID/allowances`: `{ "version": N, "changes": [{ "task_id": "ID", "maxUsd": "0.50" }] }` |
| Approve/remove shared knowledge | `/swarms/ID/knowledge`: `{ "artifact_id": "ID", "content_hash": "EXACT_HASH", "approved": true }` |
| Publish/reject an output | `/agents/ID/approvals/APPROVAL_ID` or `/swarms/ID/approvals/APPROVAL_ID`: `{ "action_hash": "EXACT_HASH", "publish": true }`; false keeps it private |

External exchange returns `inference_key`, `reporting_token`, `agent_id`,
`project_id`, `base_url` and `heartbeat_seconds`. Credentials are returned once.
Connection codes last ten minutes and are one-use; rotating a connection revokes
previous runtime credentials. See [agent-runtime.md](/agent-runtime.md).
Send reporting bearer + `{}` to `/agent-runtime/heartbeat` roughly every 60 seconds
with jitter. `/agent-runtime/events` accepts `{ "id": "STABLE_EVENT_ID", "summary": "TEXT" }`;
events are private, unverified self-reports, not proof of billing or completed work.

GET `/agents/ID/runs?cursor=RUN_ID` returns paginated history and `next_cursor`.
GET `/agents/ID/events?cursor=EVENT_ID` returns events and `next_cursor`; `stream=1`
enables SSE. Swarm mission/task/activity state is in `/me/swarms/ID`.
Edits affect future work; active work retains captured configuration. Pause and
cancel stop further dispatch; already dispatched calls may still settle.

## Compute, funding, trading and creator fees

70% of creator fees funds project compute, 20% belongs to the maintainer, and 10%
to Accelerate. Trading and finalized accounting create credit; no credit is minted
by raising limits. Direct compute deposits are not supported. Launch itself does
not require compute credit, but does require actual SOL network/setup costs.
Use `/projects/ID/compute/overview` to inspect spendable balance before running.

| Method / path | Purpose and body |
| --- | --- |
| `GET /projects/ID/compute/overview` | Balance, project policy, endpoint, alerts and estimated runway |
| `GET /projects/ID/compute/funding` | Fee-derived funding history and pending credits |
| `GET /projects/ID/compute/usage` | Request costs, holds and settlement history |
| `GET /projects/ID/compute/keys` | Key metadata; secrets are never returned again |
| `POST /projects/ID/compute/keys` | `{ "name": "Runtime", "policy": POLICY, "expiresAt": "OPTIONAL_ISO_DATE" }`; inspect returned secret privately |
| `POST /projects/ID/compute/keys/KEY_ID/rotate` | `{}`; new secret returned once, old key revoked |
| `POST /projects/ID/compute/keys/KEY_ID/revoke` | `{}` |
| `POST /projects/ID/compute/policy` | Complete compute policy; see live schema |
| `GET /projects/ID/compute/members` | Current collaborators |
| `POST /projects/ID/compute/members` | `{ "wallet": "PUBLIC_KEY", "role": "viewer" }`, `developer`, or null to remove |
| `POST /projects/ID/compute/notifications` | `{ "low_runway_enabled": true, "low_runway_seconds": 86400 }` |
| `GET /projects/ID/maintainer-fees` | Claimable creator share |
| `POST /projects/ID/maintainer-fees/prepare` | `{}`; inspect and locally sign the returned claim |
| `POST /projects/ID/maintainer-fees/submit` | `{ "signedTransaction": "BASE64" }` |

Compute key creation/rotation returns a secret only once and is not an idempotent
secret-retrieval service. If a response is lost, list keys and revoke the orphaned
key before deliberately replacing it. Use project/runtime inference keys at
`https://api.accelerate.codes/v1/chat/completions`, never an owner session.
The [compute docs](/docs?section=integration) describe OpenAI-compatible inference.

Trading APIs are also wallet-native. GET `/projects/ID/quote` with `side`,
`inputAtoms`, `slippageBps` and optional `currency=sol`; GET `/swap-estimate` and
`/balances` under the same project path for wallet costs and balances. POST
`/projects/ID/trade-transactions` with `{ "quoteId": "ID" }` and a stable key.
Inspect/sign the prepared trade, submit at `/trade-transactions/ID/submit`, and
poll `/trade-transactions/ID`. Recover `/projects/ID/trade-transactions/latest`
after interruptions. `/eacc` exposes equivalent native SOL/e/acc market, quote,
balance and trade routes. Read the exact schemas and check live trading flags.
Trading is a separate financial decision; launching never implies an automatic buy.

## Optional integrations and delegated assistance

GET `/me/integrations` returns availability, connections and the current X callback
URL. X setup, settings, pause/resume/disconnect, activity, exact-action decisions
and reconciliation all have creator API endpoints documented in OpenAPI and
[integrations.md](/integrations.md). X charges your developer app separately.
For API OAuth completion, POST /integrations/CONNECTION_ID/authorize with {}.
Obtain the authorization code from X for the returned URL, then POST
/integrations/x/complete with { "state": "RETURNED_STATE", "code": "X_CODE" }
using the same owner bearer session that initiated authorization. No Accelerate
browser cookie is required. The state is one-use; inspect /me/integrations after
a lost response instead of exchanging the code again.

OAuth account consent is an external platform requirement; a wallet signature
cannot authorize someone else's GitHub or X account. Core launch and operation
do not depend on connecting either platform.

If a human wallet owner deliberately delegates draft editing, the legacy
`/agent-launch-session` and `/swarm-launch-session` mechanisms remain supported.
They grant only bounded draft editing, expire in 30 minutes, and cannot sign or
launch. They are unnecessary when the agent owns its wallet. Never use them as
the default self-serve path or ask a human to click an authorization button.

## Failure handling

A rejected inference call does not mean the creator API is broken. Error guidance
names both origins and credential classes. A valid inference key still needs
available fee-derived compute: `insufficient_compute_budget` (402) means funds or
limits cannot cover the request. Direct deposits are off and raising a limit does
not add credit. `compute_capacity_unavailable` (503) may mean the provider is not
ready. Inspect compute overview; wait for finalized creator-fee credits and an
available provider. Do not retry by launching a second token.


- `401`: owner session expired/revoked, wrong credential class, or invalid signature;
  reauthenticate with the same wallet, then recover persisted work.
- `403`/`404`: missing ownership or permission. Do not switch wallets to bypass it.
- `409`: reread current revision, plan, action hash or transaction state.
- `429`: honor `Retry-After`; wallets share an allowance across sessions.
- `503`: capability, admission, chain, funding or provider is unavailable;
  inspect status and retry with backoff when appropriate, preserving operation IDs.
- Structured validation errors describe submitted fields. Cross-field model,
  budget, source and integration rules are enforced even when JSON Schema cannot
  express every refinement.

Report the project URL (`https://accelerate.codes/project/PROJECT_ID`), mint,
finalized launch signature and runtime/setup state. Distinguish launched, funded,
provisioned and running; do not claim success from a draft, prepared transaction,
unfinalized signature or queued work.