SYNTHOCORE DOCS

SynthoCore is an autonomous AI agent and API that turns any X/Tweet URL into a live token on Base in ~6 seconds. It compresses the entire launch workflow — ingestion, narrative analysis, art generation, deduplication, metadata pinning and onchain deployment — into a single call.

Core features

• Tweet-to-token in a single request (~5.9s median).
• Non-custodial by design — the server never holds private keys.
• LLM narrative analysis (GPT-5.4 / Claude Opus 4.6).
• Automatic token art via z-image-turbo and IPFS metadata.
• Deploy through Bankr.bot today; Doppler in Phase 2.
• Agent-first: open-source skill, SDK and CLI over one engine.

Value proposition

Narrative-driven markets reward the fastest informed actor. SynthoCore gives agents and builders a programmatic edge: the moment a high-signal account posts, an agent can evaluate the narrative and deploy a token before the market reacts — without ever surrendering custody of funds.

SynthoCore is a thin orchestration layer over best-in-class services. Heavy steps run in parallel; the only sequential dependency is unsigned-transaction construction, which waits on analysis and metadata. The diagram below shows the full 8-step pipeline.

  TWEET URL
     │
     ▼
┌─────────────┐   1. INGEST     tweet URL / watchdog trigger
│  X API v2   │ ──────────────▶ full expansions, media, author
└─────────────┘
     │
     ▼
┌─────────────┐   2. ANALYZE    GPT-5.4 / Claude Opus 4.6
│  LLM CORE   │ ──────────────▶ name, ticker, narrative, 1–5 variants
└─────────────┘
     │
     ├──────────────▶ 3. DEDUP    DexScreener + Base indexer
     │
     ▼
┌─────────────┐   4. IMAGE GEN  z-image-turbo
│  RENDERER   │ ──────────────▶ 1024×1024 token art
└─────────────┘
     │
     ▼
┌─────────────┐   5. METADATA   pin image + JSON to IPFS
│   IPFS      │ ──────────────▶ tokenURI
└─────────────┘
     │
     ▼
┌─────────────┐   6. BUILD TX   Coinbase CDP
│  CDP RPC    │ ──────────────▶ UNSIGNED Base transaction
└─────────────┘
     │
     ▼
┌─────────────┐   7. SIGN       client-side (viem / wagmi / wallet)
│  CLIENT     │ ──────────────▶ signed tx (key never leaves client)
└─────────────┘
     │
     ▼
┌─────────────┐   8. DEPLOY     Bankr.bot / Doppler
│   BASE      │ ──────────────▶ LIVE TOKEN  (~6s end-to-end)
└─────────────┘

1. Ingest — accept a tweet URL or a watchdog trigger from a monitored account.
2. Analyze — an LLM extracts a name, ticker and narrative, producing 1–5 candidate interpretations.
3. Dedup — DexScreener + a Base indexer block collisions and copy-launches.
4. Generate — z-image-turbo renders 1024×1024 token art.
5. Pin — image and metadata JSON are pinned to IPFS, yielding a tokenURI.
6. Build — Coinbase CDP constructs the unsigned Base transaction.
7. Sign — the client signs locally; the key never leaves the client.
8. Deploy — Bankr.bot or Doppler broadcasts to Base and the token goes live.

The technical flow, stage by stage:

Tweet fetching

The engine calls the X API v2 with full expansions to retrieve the author, text, media and engagement context. A watchdog mode can subscribe to specific accounts and trigger automatically on new posts.

Analysis

The tweet is passed to an LLM (GPT-5.4 or Claude Opus 4.6) which returns a structured object: token name, ticker symbol, a one-line narrative, and up to five ranked variants so an agent can pick the strongest fit.

Image generation

z-image-turbo produces 1024×1024 token art conditioned on the narrative. The result is optimized for thumbnails on DexScreener and wallet previews.

Metadata

The image and a metadata JSON document (name, symbol, description, image CID) are pinned to IPFS. The resulting tokenURI is embedded in the deployment transaction.

Doppler launch via Bankr

Coinbase CDP assembles the unsigned Base transaction targeting the chosen provider factory. After the client signs, the signed transaction is broadcast through CDP RPC and the provider (Bankr.bot or Doppler) finalizes the deployment. The token is live and tradeable on Base.

Base URL: https://api.synthocore.xyz. All requests require a bearer token. Responses are JSON.

POST /v1/launch

Builds a launch from a tweet. With sign: false (default) it returns an unsigned transaction for client-side signing.

POST /v1/launch HTTP/1.1
Host: api.synthocore.xyz
Authorization: Bearer sk_live_••••••••••••
Content-Type: application/json

{
  "tweetUrl": "https://x.com/base/status/1789012345678901234",
  "provider": "bankr",            // "bankr" | "doppler"
  "chain": "base",
  "wallet": "0xYourAgentWallet...",
  "sign": false                    // false → return unsigned tx
}

HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": "lnch_3kQ9z2",
  "status": "unsigned",
  "elapsedMs": 5912,
  "token": {
    "name": "Based Onchain Summer",
    "symbol": "BOS",
    "narrative": "Celebrating Base's onchain summer push",
    "image": "ipfs://bafybeih.../art.png",
    "tokenUri": "ipfs://bafybeic.../metadata.json"
  },
  "transaction": {
    "chainId": 8453,
    "to": "0xBankrFactory...",
    "data": "0x9f2c...e1",
    "value": "0",
    "gas": "0x4c4b40"
  },
  "submit": {
    "rpc": "https://api.developer.coinbase.com/rpc/v1/base/•••",
    "method": "eth_sendRawTransaction"
  }
}

GET /v1/launch/:id

Polls the status of a launch and returns the deployed contract once live.

GET /v1/launch/lnch_3kQ9z2

{
  "id": "lnch_3kQ9z2",
  "status": "deployed",
  "txHash": "0x71af...c0",
  "contract": "0xToken...",
  "dexUrl": "https://dexscreener.com/base/0xToken..."
}

Endpoints summary

Bankr.bot + Doppler

Bankr.bot handles fast, standardized deployment today. Doppler (Phase 2) adds dynamic bonding curves, configurable fees, non-ETH quote tokens and anti-snipe protection. Choose the provider per launch with the provider field.

Coinbase Developer Platform (CDP)

All transaction construction and RPC submission run over the Coinbase Developer Platform. See section 7 for the detailed integration.

SDK usage

Install the TypeScript SDK and launch in three steps — build, sign locally, submit.

import { SynthoCore } from "@synthocore/sdk"
import { privateKeyToAccount } from "viem/accounts"

const synto = new SynthoCore({ apiKey: process.env.SYNCO_API_KEY })
const account = privateKeyToAccount(process.env.AGENT_PK as `0x${string}`)

// 1. Build the launch (server returns an UNSIGNED tx)
const launch = await synto.launch({
  tweetUrl: "https://x.com/base/status/1789012345678901234",
  provider: "doppler",
})

// 2. Sign locally — the key never touches SynthoCore servers
const signed = await account.signTransaction(launch.transaction)

// 3. Broadcast over Coinbase CDP RPC
const { txHash, contract } = await synto.submit(launch.id, signed)
console.log("Live on Base:", contract, txHash)

CLI usage

The CLI wraps the same engine and signs with your local keystore.

# install
npm i -g @synthocore/cli

# authenticate
synto login

# launch a token from a tweet (signs with your local keystore)
synto launch https://x.com/base/status/1789012345678901234 \
  --provider doppler \
  --chain base

# check status
synto status lnch_3kQ9z2

Skill for AI agents

Drop the open-source skill manifest into any agent runtime to expose tweet-to-token as a callable tool.

// v0_memories / agent skill manifest
{
  "name": "synthocore-launch",
  "description": "Turn any X/Tweet URL into a live token on Base in ~6s.",
  "trigger": ["launch token", "tweet to token", "deploy on base"],
  "inputs": { "tweetUrl": "string", "provider": "bankr|doppler" },
  "endpoint": "https://api.synthocore.xyz/v1/launch",
  "auth": "bearer",
  "nonCustodial": true
}

SynthoCore is non-custodial by construction. The server builds an unsigned transaction and returns it to the client — it never receives, stores, or sees a private key.

How keys are handled

• The API returns an unsigned transaction payload only. There is no endpoint that accepts a private key.
• Signing happens client-side (viem/wagmi, a local keystore, or any wallet). The key never leaves the client environment.
• The signed transaction is broadcast over CDP RPC. Server-side key custody is removed as an attack surface entirely.
• API endpoints are parameterized and rate-limited; the agent skill is Apache-2.0.

The Coinbase Developer Platform is the onchain backbone of the pipeline. SynthoCore uses CDP for two things:

1. Transaction construction — at step 6, CDP assembles the unsigned Base transaction (factory call, tokenURI, gas estimate, chainId 8453) ready for client signing.
2. RPC submission — at step 8, the signed transaction is broadcast through managed CDP RPC with request signing, giving reliable, low-latency inclusion on Base.

Because CDP handles RPC and tx-building while the client retains signing authority, the system gets enterprise-grade infrastructure without compromising the non-custodial model.

Phase 1 — Live

• Tweet-to-token engine on Base with Bankr.bot deployment.
• Non-custodial unsigned-tx flow over Coinbase CDP.
• Public REST API, TypeScript SDK and CLI.
• Open-source agent skill (Apache-2.0).

Phase 2 — In progress

• Doppler provider: dynamic bonding curves and configurable fees.
• Non-ETH quote tokens and anti-snipe protection.
• Watchdog mode: auto-launch from monitored accounts.
• Multi-variant ranking and human-in-the-loop approval hooks.

Phase 3 — Planned

• $SYNCO DAO governance over the protocol treasury.
• Operator revenue share and priority launch lanes.
• Agent network coordination and reputation scoring.
• Additional chains and provider integrations.