# AI agents that research, reason, and deliver — benchmarked #1 for accuracy.

Canonical URL: https://www.getspine.ai/

Spine orchestrates 300+ AI models as parallel agents to conduct deep research and produce polished reports, slides, spreadsheets, and dashboards — ranked #1 on Google DeepMind’s DeepSearchQA benchmark.

## Parallel agent swarms, not one-at-a-time chat

Dispatch a brief and Spine runs research, synthesis, and document creation in parallel. Multiple agents each handle a workstream and pass structured output to the next, returning a complete deliverable rather than a thread of text responses.

## State-of-the-art research, benchmarked #1

Spine Deep Research scores 87.6% on Google DeepMind’s DeepSearchQA — the hardest public multi-step research benchmark — ahead of Perplexity Deep Research (79.5%), Claude (76.1%), ChatGPT (71.3%), and Gemini Deep Research (66.1%).

## Client-ready output in real formats

Goldman Sachs-style reports, .pptx strategy decks, .docx briefs, Excel models with formulas and scenario tabs, competitive benchmarks, financial projections, and interactive dashboards — formatted and ready to send, not rough drafts.

## Automations across your apps

Schedule recurring Spine workflows (daily, weekly, monthly, or custom) and connect them to the tools you already use via integrations, MCP, API, and webhooks.

## Use cases by role

### Investors

Market sizing, competitive landscapes, earnings analysis, and investment memos — from public filings and data.

- Build a TAM/SAM/SOM model for [market] triangulating industry reports, public company disclosures, and analyst estimates — with sources, assumptions, and scenario tabs
- Research 15+ companies in [sector], their positioning, funding, revenue signals, and key risks — produce an investment thesis memo with comparable valuations
- Analyze the last 4 quarters of earnings calls for [company] and its 5 closest peers — extract sentiment shifts, guidance changes, and strategic pivots into a cross-company trend report
- Research SEC filings, insider transactions, and 13F institutional ownership changes for [company] over the past 6 months — produce a smart money signals report with charts

### Consultants

Industry landscapes, market sizing, due diligence, and competitive intelligence — client-ready in minutes.

- Research the [industry] landscape: map the top 15 companies by segment, their positioning, pricing, funding, key customers, and the 3 most underserved segments — produce a strategy deck
- Produce a market sizing report for [industry] with bottom-up and top-down estimates, triangulating industry reports, public disclosures, and analyst data — with methodology and source citations
- Build a commercial due diligence report on [company]: market position, competitive moat, management team assessment, customer concentration risk, and key person dependencies — citing 20+ public sources
- Produce a competitive intelligence brief across 10 competitors in [market]: pricing changes, product launches, executive hires, funding rounds, and regulatory actions from the past 90 days

### Legal

Case law research, regulatory tracking, patent landscapes, and litigation prep — with citations.

- Research [judge]'s last 50 rulings in [case type]: judicial philosophy, procedural preferences, sentencing patterns, plus opposing counsel's win rate and strategic tendencies — produce a litigation prep memo
- Track all regulatory changes affecting [sector] in the past 12 months across federal and state agencies — produce a compliance impact report with deadlines, required disclosures, and action items
- Map the patent landscape for [technology]: key patent holders, recent grants and applications, ongoing disputes, licensing structures, and freedom-to-operate analysis — produce a landscape report with claim charts
- Research case law on [topic] across federal circuits and key state jurisdictions — produce an analysis brief with precedent chain, current circuit splits, and practical litigation guidance

### Medical

Literature reviews, guideline comparisons, trial pipelines, and FDA safety monitoring — with citations.

- Conduct a systematic literature review on [treatment] for [condition]: search PubMed, Cochrane, and recent RCTs — grade evidence quality using GRADE and produce a structured summary with 30+ citations
- Compare current guidelines from AHA, ESC, NCCN, and WHO for [condition]: drug classes, dosing, sequencing, and monitoring — produce a side-by-side decision matrix with level-of-evidence ratings
- Map the entire clinical trial pipeline for [disease area]: all active Phase II/III trials from ClinicalTrials.gov with mechanisms of action, sponsors, primary endpoints, enrollment status, and expected readout dates
- Research all FDA drug safety communications, REMS modifications, and label changes in [therapeutic area] from the past 12 months — produce a pharmacovigilance report organized by drug class with clinical implications

### Founders

Competitive landscapes, investor research, market intelligence, and buyer analysis — from public signals.

- Map the competitive landscape for [market]: top 15 players with positioning, pricing, features, funding history, estimated revenue, employee count, and whitespace opportunities — produce a competitive matrix
- Research the funding landscape for [sector]: who's investing at what stages and valuations, which companies raised recently, each major VC's thesis — produce a ranked investor target list for a [stage] startup
- Deep-dive [competitor] from public signals: product launches from changelogs, hiring patterns from 50+ job postings, customer sentiment from G2/Reddit reviews, and pricing changes — produce a competitive intelligence dossier
- Research the buyer landscape for [product category]: who buys (titles, company size), what they use today, pain points from G2/Reddit/forums, willingness to pay, and switching triggers — produce a buyer persona report

### GTM & Sales

Account research, buyer intent signals, outreach personalization, and deal intelligence — from public footprints.

- Research [target account]: org structure, recent initiatives, tech stack (from job postings), strategic priorities (from earnings/press), and key decision-makers — produce a pre-call account brief with 5 personalized talking points
- Find buying intent signals for [product category] across 20 target accounts: recent job postings mentioning relevant tools, leadership changes, funding events, tech stack changes, and pain points from reviews — produce a prioritized outbound list
- Research [prospect name + company]: their LinkedIn background, recent posts and talks, company priorities, competitive tools they use, and mutual connections — produce a hyper-personalized outreach sequence with 3 email drafts
- Analyze how the top 10 companies in [sector] position and sell [product type]: pricing pages, case studies, sales collateral, G2 comparisons, and objection patterns from reviews — produce a competitive battle card

### Insurance

Regulatory intelligence, market benchmarking, catastrophe analysis, and emerging risk research — from public filings.

- Research the regulatory landscape for [line of business] insurance across the top 10 US states by premium volume: rate filing decisions, new coverage mandates, pending legislation, and enforcement actions — produce a state-by-state matrix
- Analyze the latest statutory filings for the top 10 [line of business] insurers: combined ratios, loss reserve development, premium growth, expense ratios, and market share shifts — produce a competitive benchmarking report
- Research catastrophe losses in [region/peril] over the past 24 months: insured loss estimates by modeler, affected carriers, reinsurance market capacity shifts, and pricing implications — produce a cat loss trends report
- Research emerging risks in [area, e.g. PFAS / cyber ransomware / climate litigation]: current claims landscape, regulatory developments, coverage disputes, and how top 10 carriers are responding — produce a market intelligence briefing

### Finance

Peer comparisons, earnings analysis, M&A comps, and target screening — from public filings and transcripts.

- Pull the last 8 quarters of financials for [company] and its top 5 peers from SEC filings — build a peer comp with revenue growth, margin trends, leverage ratios, and valuation multiples, flagging outliers
- Analyze this quarter's earnings across 10 companies in [sector]: management commentary themes, guidance revisions, margin drivers, and capex outlook — produce a sector earnings digest
- Research all M&A transactions in [sector] over the past 3 years: deal values, multiples paid (EV/Revenue, EV/EBITDA), strategic rationale, and buyer profiles — produce a precedent transaction comp table
- Screen 50+ potential M&A targets in [sector] against criteria (revenue, growth, margins, geography) — produce a ranked shortlist with valuation estimates, strategic fit scores, and recent developments

## Who Spine is for

### Founders (https://www.getspine.ai/founders)

High-signal research for fundraising and go-to-market: investor decks, TAM/SAM/SOM, competitive landscapes, GTM plans, and decision memos.

### Consultants (https://www.getspine.ai/consultants)

Research and deliverables in minutes, not days: strategy decks, RFP responses, market sizing, due diligence, and recurring competitive intelligence.


---

# Spine — Pricing

Canonical URL: https://www.getspine.ai/pricing

Spine uses a credit system. Credits are consumed when blocks generate new content or an agent runs a task. Plans below are for individual subscribers; Enterprise pricing is custom.

## Free — $0/month

- 2,000 credits/month
- AI agent swarms that build deliverables on your canvas
- Access to 300+ AI models
- Unlimited canvases
- Automations, integrations, MCP/API
- Standard processing speed
- All block types
- Upload files, LLM chats, YouTube videos, and more

## Starter

Includes everything in Free, plus unlimited teammates (shared credits), 2× faster processing, and ad-hoc credit top-ups.

| Credits / month | Monthly billing | Annual billing | Daily refresh |
| --- | --- | --- | --- |
| 30,000 | $20/mo | $16/mo | 1,500 |
| 50,000 | $30/mo | $24/mo | 1,750 |
| 75,000 | $40/mo | $32/mo | 2,000 |
| 100,000 | $50/mo | $40/mo | 2,250 |

## Max

Includes everything in Starter, plus 4× faster processing, priority queue during peak load, and priority support.

| Credits / month | Monthly billing | Annual billing | Daily refresh |
| --- | --- | --- | --- |
| 200,000 | $100/mo | $80/mo | 5,000 |
| 350,000 | $149/mo | $120/mo | 6,000 |
| 500,000 | $199/mo | $159/mo | 7,500 |
| 750,000 | $299/mo | $239/mo | 10,000 |

## Enterprise — Custom

Contact support@getspine.ai. Includes custom credit allocation, SSO, team management, dedicated support, team access controls, custom integrations, and SOC 2 documentation available on request.

## Ad-hoc credit top-up

10,000 credits for $10. One-time purchase. No subscription change. Credits never expire.

## Real tasks, real costs

| Task | Typical cost |
| --- | --- |
| Comprehensive competitive analysis | ~5,000 credits |
| Beautifully designed landing page | ~3,000 credits |
| Data pipeline in Excel | ~5,000 credits |
| Investor pitch deck | ~6,000 credits |
| Quick email draft | ~70 credits |
| In-depth research report | ~4,000 credits |
| PRD to interactive prototype | ~3,000 credits |
| Simple image generation | ~100 credits |
| Blog post from outline | ~500 credits |

## FAQ

### What are credits?

Credits are the currency for generating content on the canvas and running tasks with agents. The exact amount depends on the complexity of what you're creating and how many blocks are involved.

### What's the launch bonus?

Every plan — including Free — receives a one-time bonus of 3,000 credits during our launch week. These credits are added on top of your normal monthly allocation and are consumed after your daily bonus but before your monthly credits.

### How much do specific blocks cost?

Block costs fall into two tiers. Standard blocks — like Prompt and Image Generation — are lighter operations that typically start around 50–100 credits. Agentic blocks — like Slides, Documents, Excel, Browser, and Apps — coordinate multiple steps and typically start around 500–700 credits, scaling higher with more input. Costs also increase when blocks have more connected inputs, since each connection adds context that needs to be processed.

### How do agents consume credits?

When you dispatch a task, the agent assesses your prompt and decides which blocks to create to complete your objective. It might generate a single block for a simple request or build out several blocks across different types for a complex one. You're only charged for the blocks the agent actually runs — nothing more. The total cost depends on how many blocks are created, how complex each one is, and how many inputs are connected to them.

### Why do some blocks and tasks cost more than others?

It depends on what the block does. Some blocks perform a single, focused operation — like generating a prompt response or an image. Others — like creating a slide deck, a document, or a spreadsheet — coordinate multiple steps behind the scenes and require more processing. The amount of input being processed also matters: blocks with more content or more connected inputs cost more to run. In general, simpler and more focused tasks will cost less.

### Can I know exactly how many credits a task will use?

Because agents determine what's needed to complete your objective, credit consumption varies from task to task. A straightforward request might only need one or two blocks, while a complex one might require ten or more — each with different costs depending on its type and inputs. The task estimates above give a realistic sense of what common requests cost. To stay in control before a task runs, use plan mode: you can review the agent's proposed approach, adjust it, or ask for a simpler plan to reduce scope and cost.

### What can I do without spending credits?

Writing notes, uploading files, websites, images, and documents to your canvas is always free. Arranging, connecting, and organizing blocks costs nothing. Credits are only consumed when a block generates new content or an agent runs a task.

### How can I make my credits go further?

Start with plan mode. Before any task runs, plan mode lets you review the agent's proposed approach and adjust it — ask for something simpler and the agent will adapt. Beyond plan mode: add relevant files, documents, or websites to your canvas before starting a task, so agents can use that context directly instead of searching for it themselves. If you only need a high-level overview, say so in your prompt — this signals the agent to keep research minimal. Asking for a narrower scope, like a single section instead of a full report, generally leads to fewer blocks and lower overall cost.

### What order are my credits consumed in?

Credits are consumed in a specific order to maximize the value of your subscription. First, your Daily Bonus credits are used — these reset at midnight UTC and don't roll over. Next, your Monthly Credits are drawn from, which refill on your billing date. Finally, any Credit Pack balance is used. Credit packs are purchased separately and never expire, so they act as a reliable backup.

### Do unused tokens roll over to the next month?

No — unused credits do not currently roll over. They either expire daily or monthly, depending on which pool they came from. The only credits that never expire are add-on credits.

### How does the daily bonus work?

Pro and Max subscribers receive bonus credits every day at midnight UTC. These are "use it or lose it" — they don't roll over to the next day. Daily bonus credits are consumed first, before your monthly pool is touched.

### What happens when I run out of credits?

You have several ways to keep working: buy a credit pack to resume instantly with credits that never expire (Pro and Max subscribers only), upgrade your plan for more monthly and daily credits immediately, wait for your daily bonus to reset at midnight UTC (Pro and Max subscribers only), or wait for your monthly reset on your billing date.

### Do credit packs expire?

No. Credit packs are a one-time purchase and the credits never expire. They remain in your account until you use them, regardless of your subscription plan. Credit packs are available to Pro and Max subscribers only.

### Is upgrading always better than buying packs?

It depends on your usage pattern. If you use Spine consistently every month, upgrading gives you the best per-credit value plus daily bonus credits. If your usage is bursty or occasional, credit packs let you pay only when you need more — and they never expire.

### Do you offer a student discount?

Yes. If you're currently enrolled at a university, email support@getspine.ai from your university email, or attach proof of enrollment (such as a current student ID or enrollment verification letter), and we'll set you up with a discounted plan.


---

# State-of-the-art research and polished deliverables, all in one API.

Canonical URL: https://www.getspine.ai/api

Spine orchestrates parallel agents across 300+ models, runs deep research, and returns client-ready slides, docs, spreadsheets, images, and reports.

- **Try the Playground**: https://platform.getspine.ai ($10 in free credits on us)
- **Read the docs**: https://docs.getspine.ai

## #1 on DeepSearchQA — by 8 points.

Spine Deep Research scores 87.6% on DeepSearchQA, ahead of Perplexity (79.5%), Claude (76.1%), ChatGPT (71.3%), and Gemini Deep Research (66.1%) on the same public eval.

[Read the benchmark write-up](https://www.getspine.aihttps://blog.getspine.ai/spine-swarm-hits-1-on-gaia-level-3-and-google-deepmind-deepsearchqa)

## How it works

1. **Start a run via REST** — POST a prompt (and an optional template — slides, deep_research, report, excel, memo, app, landing_page) to /v1/run. You get a run_id back immediately — no long-lived connection required.
2. **Async by design** — One POST kicks off the agent swarm; webhook callbacks notify your app the moment results are ready.
3. **Receive polished deliverables** — Download .pptx decks, .docx briefs, Excel models with formulas, images, JSON research reports with citations, or interactive dashboards — whatever the task called for.

## REST endpoints

Small surface. Full reference at https://docs.getspine.ai.

| Method | Path | Purpose |
| --- | --- | --- |
| `POST` | `/v1/run` | Start an async run (multipart form). Returns a run_id immediately. |
| `GET` | `/v1/run/{run_id}` | Poll status, retrieve final output and downloadable artifacts. |
| `GET` | `/v1/canvas/{id}/dag` | Block graph (nodes and edges) for the canvas this run produced. |
| `GET` | `/v1/canvas/{id}/tasks` | Task tree — every agent action, sub-task, and intermediary output. |

## Submit a task

### curl

```bash
# 1. Start a run
curl -X POST https://api.getspine.ai/v1/run \
  -H "X-API-KEY: $SPINE_API_KEY" \
  -F 'prompt=Build an investor-ready competitive analysis for the AI coding assistants space.' \
  -F 'template=slides'
# → { "data": { "run_id": "...", "status": "running" } }

# 2. Poll until done
curl https://api.getspine.ai/v1/run/<run_id> \
  -H "X-API-KEY: $SPINE_API_KEY"
# → { "data": { "status": "completed",
#       "artifacts": [{ "name": "deck.pptx", "download_url": "..." }] } }
```

### JavaScript (fetch)

```javascript
import { Spine } from "spine-sdk";

const spine = new Spine({ apiKey: process.env.SPINE_API_KEY });

const run = await spine.runs.create({
  prompt: "Build an investor-ready competitive analysis for the AI coding assistants space.",
  template: "slides",
});
const result = await spine.runs.waitForCompletion(run.run_id);

for (const a of result.result.artifacts) {
  console.log(a.name, a.download_url);
}
```

### Python (httpx)

```python
from spine import SpineClient, Template

with SpineClient() as client:  # picks up SPINE_API_KEY from env
    run = client.runs.create(
        prompt="Build an investor-ready competitive analysis for the AI coding assistants space.",
        template=Template.SLIDES,
    )
    result = run.wait()

    for a in result.artifacts:
        print(a.name, a.download_url)
```

## Pay as you go. No subscriptions.

- $1 = 1,000 credits
- $10 free to try

Sign up at platform.getspine.ai and get $10 in free credits on us — enough to run several real tasks. No subscriptions, no seats, no monthly minimums.

Using Spine on the web instead? See Canvas pricing: https://www.getspine.ai/pricing

## Docs

Full request/response schemas, deliverable formats, and error codes: https://docs.getspine.ai

---

# API Reference

Base URL: `https://api.getspine.ai`

## Works inside every agentic surface

Spine is a REST API — call it from any coding agent, IDE, or chat. Paste this page into the agent and it has everything it needs.

- **Claude** — Turn any Claude turn into a 50-page investment memo or a 30-slide deck — not just a message.
- **Cursor** — Cursor agents ship research memos, decks, and spreadsheets from a rule file — not just code.
- **Replit** — Replit apps pull real research and client-ready artifacts inline — no more placeholder content.
- **Codex** — Give the Codex CLI long-running research agents and polished deliverables behind one REST call.
- **Lovable** — Lovable apps produce real investor decks, market memos, and research reports for end users.
- **OpenClaw** — OpenClaw agents ship real research briefs, decks, and spreadsheets — not just local-system actions.
- **Hermes** — Hermes agents send polished client deliverables as fast as they send messages.

Agent integration guide: https://docs.getspine.ai/api-reference/for-agents

## Authentication

All endpoints require an `X-API-KEY` header. Get a key from the Spine dashboard → Settings → Developer Keys. Keys can be rotated or revoked at any time.

```
X-API-KEY: sk_spine_...
```

## Endpoints

| Method | Path | Purpose |
| --- | --- | --- |
| `POST` | `/v1/run` | Start an async run (multipart form). Returns a run_id immediately. |
| `GET` | `/v1/run/{run_id}` | Poll status, retrieve final output and downloadable artifacts. |
| `GET` | `/v1/canvas/{id}/dag` | Block graph (nodes and edges) for the canvas this run produced. |
| `GET` | `/v1/canvas/{id}/tasks` | Task tree — every agent action, sub-task, and intermediary output. |

## Start a run — request parameters

`POST /v1/run` accepts a `multipart/form-data` body with the following fields:

| Field | Required | Type | Description |
| --- | --- | --- | --- |
| `prompt` | yes | string | Natural-language description of what to produce. |
| `template` | no | string | One of: auto, deep_research, report, slides, memo, excel, app, landing_page. Defaults to 'auto'. |
| `blocks` | no | JSON array | Advanced: pass an explicit array of block definitions to override the template. See valid block types above. |
| `agent_instructions` | no | string | Natural-language directive injected into every agent layer to shape tone, depth, scope, and citation requirements. Additive to template/blocks. |
| `files` | no | file[] | Attach images (PNG/JPEG/GIF/WEBP/SVG) or documents (PDF/DOCX/XLSX/CSV/TXT/MD/YAML/JSON/ZIP) as agent context. Repeat the field for multiple files. |

## Templates

Pass one of the following `template` values, or pass `blocks` (a JSON array of block definitions) for finer control. `blocks` overrides the template.

| id | what it does | output |
| --- | --- | --- |
| `auto` | Let Spine pick blocks based on the prompt | Varies |
| `deep_research` | Multi-source research with citations | Memo (.docx) |
| `report` | Structured report with sections | Report (.docx) |
| `slides` | Presentation deck | Slides (.pptx) |
| `memo` | Short executive memo | Memo (.docx) |
| `excel` | Spreadsheet analysis | Workbook (.xlsx) |
| `app` | Single-page web app | App (.html) |
| `landing_page` | Marketing landing page | Page (.html) |

## Block types (for `blocks` override)

`prompt-block`, `list-block`, `memo-block`, `document-block`, `excel-block`, `deep-research-block`, `image-block`, `presentation-block`, `app-block`, `table-block`, `prototype-block`, `landing-page-block`, `text-block`, `web-block`, `yt-block`, `web-research-block`, `file-block`.

## Agent instructions

`agent_instructions` is a natural-language directive injected into system prompts at every agent layer (orchestrator, strategist, persona agents, block operators). Additive to `template` and `blocks` — combine all three in one request.

| Instruction | Effect |
| --- | --- |
| "Be thorough, verify all claims with 2+ sources" | More personas spun up, verification steps inserted |
| "Prioritize speed, minimal verification" | Single persona, cross-checks skipped |
| "Write for a C-suite executive audience" | Executive tone across all outputs |
| "Focus on European markets only" | Research scoped geographically |
| "Include source citations for every claim" | Citation requirements injected into per-block prompts |

```bash
curl -X POST https://api.getspine.ai/v1/run \
  -H "X-API-KEY: sk_spine_..." \
  -F "prompt=Analyze the competitive landscape for AI coding tools" \
  -F "template=deep_research" \
  -F "agent_instructions=Be thorough, verify all claims with 2+ sources. Write for a technical audience."
```

## File uploads

Attach files via the `files` field on `POST /v1/run`. They ride along as `multipart/form-data` and become blocks on the resulting canvas.

| Kind | Block type | Supported types |
| --- | --- | --- |
| Images | `image-block` | PNG, JPEG, GIF, WEBP, SVG |
| Documents | `file-block (indexed for agent access)` | PDF, DOCX, XLSX, CSV, TXT, MD, YAML, JSON, ZIP |

```bash
curl -X POST https://api.getspine.ai/v1/run \
  -H "X-API-KEY: sk_spine_..." \
  -F "prompt=Summarize this sales data and create a chart" \
  -F "template=report" \
  -F "files=@sales-data.csv;type=text/csv" \
  -F "files=@revenue-chart.png;type=image/png"
```

- Multiple files can be attached in a single request — repeat `-F "files=@..."` per file.
- Image files become `image-block`s and are available to downstream agents by visual reference.
- Document files are indexed at ingest time so every agent in the run can query them.
- Maximum file size and total attachment limits apply per plan.

## Run statuses

| Status | Meaning | Terminal? |
| --- | --- | --- |
| `running` | Agents still executing | No |
| `completed` | All agents finished, results available | Yes |
| `partial` | Some blocks failed but usable results exist | Yes |
| `failed` | Run failed — see `errors` array | Yes |

Runs average 10–20 minutes; complex research can take up to 2 hours. Poll every 15–30 seconds, or use a backoff (start at 15 s, grow to 60 s) to reduce traffic on longer runs. Webhooks (below) are the preferred integration path.

## Response shapes

Run just started:

```json
{
  "data": {
    "run_id": "01HXZJ4P...K3Q9",
    "status": "running"
  }
}
```

While running:

```json
{
  "success": true,
  "data": {
    "run_id": "uuid",
    "status": "running",
    "canvas_id": "uuid",
    "progress": {
      "tasks_completed": 3,
      "tasks_total": 8,
      "elapsed_ms": 480000
    }
  }
}
```

Run completed:

```json
{
  "data": {
    "status": "completed",
    "result": {
      "final_output": "<summary text>",
      "artifacts": [
        { "name": "deck.pptx", "download_url": "https://..." }
      ]
    }
  }
}
```

Run failed:

```json
{
  "success": true,
  "data": {
    "run_id": "uuid",
    "status": "failed",
    "errors": [{ "error": "Agent execution failed" }]
  }
}
```

## Full polling loop (Python)

```python
import os, time, httpx

API_KEY = os.environ["SPINE_API_KEY"]
BASE = "https://api.getspine.ai"
H = {"X-API-KEY": API_KEY}

def run(prompt, template="auto", **kwargs):
    r = httpx.post(f"{BASE}/v1/run", headers=H,
                   data={"prompt": prompt, "template": template, **kwargs})
    run_id = r.json()["data"]["run_id"]

    while True:
        p = httpx.get(f"{BASE}/v1/run/{run_id}", headers=H).json()["data"]
        if p["status"] in ("completed", "partial", "failed"):
            return p
        time.sleep(5)

result = run("Build a landing page for an AI sales tool", template="landing_page")
print(result["result"]["final_output"])
for a in result["result"]["artifacts"]:
    print(a["name"], "→", a["download_url"])
```

## Use as a tool inside Claude / Anthropic SDK

```typescript
// Use Spine as a tool inside the Anthropic SDK
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const tool = {
  name: "spine_run",
  description: "Spawn a multi-agent Spine run that produces research, memos, decks, excel, or apps.",
  input_schema: {
    type: "object",
    properties: {
      prompt: { type: "string" },
      template: {
        type: "string",
        enum: ["auto", "deep_research", "report", "slides", "memo", "excel", "app", "landing_page"],
      },
    },
    required: ["prompt"],
  },
};

const resp = await client.messages.create({
  model: "claude-sonnet-4-5",
  max_tokens: 2048,
  tools: [tool],
  messages: [{ role: "user", content: "Make a market report on AI agents" }],
});
// On stop_reason="tool_use" → POST /v1/run, poll GET /v1/run/{run_id}, feed result back.
```

The `spine_run` tool kicks off a run; your agent should hand the user the `run_id` and stop, or poll `GET /v1/run/{run_id}` on its own.

## Auditable trace

Spine returns a step-by-step trace of every agent action, sub-task dispatched, and intermediary output produced. Debug runs, cite sources, or show your work to clients — nothing is a black box.

Fetch the full task tree (every agent dispatch, tool call, and intermediary output) with `GET /v1/canvas/{id}/tasks`. Fetch the block graph (nodes and edges) with `GET /v1/canvas/{id}/dag`.

### Example task tree

- **Morning Brief: Axios + Mercor + Claude leak coverage** _[task]_
  - **Axios Attacks Researcher** _[persona]_
    - **Create Plan Note** _[agent]_
    - **Research: Supply-chain Attack Vectors** _[agent]_
      - `axios-research-block` _[block]_
  - **Morning Brief Synthesizer** _[persona]_
    - **Compose Exec Memo** _[agent]_
      - `synthesis-memo-block` _[block]_
    - **Render Dashboard** _[agent]_
      - `deck.pptx` _[block]_

The same run renders as a canvas DAG at `GET /v1/canvas/{id}/dag` — 7 nodes, 6 dependency edges.

## Webhooks

Webhooks let your app react to run lifecycle events without polling. Spine POSTs a signed JSON envelope to a URL you configured (per workspace in the developer portal); you verify it with a shared secret.

### Event types

| Event | Fires when |
| --- | --- |
| `run.started` | Immediately after `POST /v1/run` creates the run. |
| `run.completed` | The run reaches terminal status `completed`. Includes `final_output` and artifacts. |
| `run.failed` | The run reaches terminal status `failed`. Includes the error message. |
| `webhook.ping` | Fired by **Send test event** in the portal — use it to exercise your verifier. |

### Event envelope

```json
{
  "id": "evt_78ffe7c625d94d2192b2f5a8d63933a6",
  "type": "run.completed",
  "created": 1745251200,
  "livemode": true,
  "api_version": "2026-04-01",
  "data": {
    "object": {
      "run_id": "06bb6cee-7982-48af-acd4-05d21ce39ed5",
      "canvas_id": "3c86545a-2e06-4c29-aac5-557f897c8ada",
      "status": "completed",
      "duration_ms": 10736,
      "artifacts": [],
      "final_output": "2 + 2 equals 4."
    }
  }
}
```

### Request headers

```
Content-Type: application/json
User-Agent: Spine-Webhooks/1.0
Spine-Signature: t=1745251200,v1=5fe3f78dbf86c53084d1bd1222005d3c064567937e5ceafb904e30551fdb89ad
Spine-Event-Id: 37070895-029a-4802-a5da-4052e7964cc3
Spine-Event-Type: run.completed
```

`Spine-Signature` is `t={unix_ts},v1={hex}` — timestamp and HMAC-SHA256 over `{t}.{raw_body}`. `Spine-Event-Id` equals `event.id`; persist it to dedupe.

### Verify the signature

Always verify before processing — anyone who learns your URL can send unsigned POSTs.

1. Parse the header — split on `,` to extract `t` (unix seconds) and every `v1=` value.
2. Check freshness — reject if `abs(now - t) > 300` to block replayed deliveries.
3. Rebuild the signed payload — literally `{t}.{raw_body}` using the **raw request body bytes**, not the parsed JSON.
4. Recompute the HMAC — `HMAC-SHA256(secret, signed_payload)` as a lowercase hex digest.
5. Constant-time compare against any `v1` value. Use `hmac.compare_digest` (Python) or `crypto.timingSafeEqual` (Node) — never `==`.

```python
import hmac, hashlib, time

TOLERANCE_SECONDS = 300

def verify_spine_webhook(secret: str, raw_body: bytes, header: str) -> bool:
    pairs = [kv.split("=", 1) for kv in header.split(",") if "=" in kv]
    t = next((v for k, v in pairs if k == "t"), None)
    v1s = [v for k, v in pairs if k == "v1"]
    if not t or not v1s:
        return False
    if abs(int(time.time()) - int(t)) > TOLERANCE_SECONDS:
        return False
    expected = hmac.new(
        secret.encode(), f"{t}.".encode() + raw_body, hashlib.sha256
    ).hexdigest()
    return any(hmac.compare_digest(expected, v) for v in v1s)
```

```typescript
import crypto from "node:crypto";

const TOLERANCE_SECONDS = 300;

export function verifySpineWebhook(
  secret: string,
  rawBody: Buffer | string,
  header: string,
): boolean {
  const pairs = header.split(",").map((s) => s.trim().split("="));
  const t = pairs.find(([k]) => k === "t")?.[1];
  const v1s = pairs.filter(([k]) => k === "v1").map(([, v]) => v);
  if (!t || v1s.length === 0) return false;
  if (Math.abs(Math.floor(Date.now() / 1000) - parseInt(t, 10)) > TOLERANCE_SECONDS) {
    return false;
  }
  const body = typeof rawBody === "string" ? Buffer.from(rawBody, "utf8") : rawBody;
  const signed = Buffer.concat([Buffer.from(`${t}.`), body]);
  const expected = crypto.createHmac("sha256", secret).update(signed).digest("hex");
  const e = Buffer.from(expected);
  return v1s.some((s) => {
    const b = Buffer.from(s);
    return b.length === e.length && crypto.timingSafeEqual(e, b);
  });
}
```

### Operational notes

- Return any `2xx` status within 10 seconds — anything else is recorded as `failed`. Acknowledge fast, process async.
- Persist `Spine-Event-Id` alongside downstream effects to dedupe resends and repeat triggers.
- The `whsec_...` secret is shown exactly once when you create or rotate an endpoint. Store it in a secret manager.
- Use `*` in the events list to subscribe an endpoint to every event type, including ones added later.
- HTTPS is enforced in production.

## Errors

Errors return `{ "success": false, "error": "..." }` with one of these HTTP codes:

| Code | Reason |
| --- | --- |
| `400` | Bad template, malformed blocks, or invalid UUID. |
| `401` | Missing or invalid X-API-KEY. |
| `404` | Run or canvas not found (or not owned by the authenticated key). |
| `500` | Server error — retry with exponential backoff. |


---

# High-signal research for fundraising and go-to-market.

Canonical URL: https://www.getspine.ai/founders

Spine runs parallel research agents to build investor-ready narratives, defensible market intelligence, and execution-ready GTM plans — without losing context across threads, companies, and drafts.

## Top workflows

- **GTM plan** — ICP, channels, sales motion, and a 90-day execution roadmap.
- **Competitive landscape** — Pricing, positioning, features, funding, and strategic direction.
- **Fundraising deck** — TAM/SAM/SOM, comps, positioning, trends, and projections for slides.

## The most accurate AI research and reasoning on the market.

Fundraising and GTM decisions depend on defensible facts. DeepSearchQA is Google DeepMind’s hardest benchmark for multi-step research — how well an AI finds, cross-checks, and reasons over real information. Spine ranks #1 ahead of every major alternative.

- **Spine Deep Research**: 87.6%
- Perplexity Deep Research: 79.5%
- Claude: 76.1%
- ChatGPT: 71.3%
- Gemini Deep Research: 66.1%

Source: [Google DeepMind DeepSearchQA](https://blog.getspine.ai/spine-swarm-hits-1-on-gaia-level-3-and-google-deepmind-deepsearchqa/) · 900-question benchmark · February 2026

## What is Spine?

Spine is an agentic platform that leverages 300+ AI models to conduct research, create deliverables, and automate work across all your apps — so you can move faster with higher confidence.

1. **Describe what you’re building** — Share the product, who it’s for, and what decision you need to make — deck narrative, market entry, ICP, or outreach.
2. **Agents run workstreams in parallel** — Market sizing, comps, competitors, pricing, trends, and customer pain points — researched simultaneously, cross-checked across sources.
3. **Investor and execution-ready output** — Spine produces structured deliverables you can ship: decks, memos, competitive matrices, and GTM plans — with clear rationale.

## What can Spine do for you?

Spine agents can automate the following workflows for founders.

- **Deep Research** — Cross-referenced web agents across 50+ live sources
- **Investor Decks** — Narratives, market maps, comps, and slide-ready structure
- **Decision Memos** — Clear trade-offs and recommendations with supporting evidence
- **Financial Projections** — Assumptions, scenarios, and sensitivity analysis you can edit
- **Competitive Landscapes** — Pricing, positioning, features, funding, and strategic direction
- **GTM Plans** — ICP, channels, funnel assumptions, and execution roadmap
- **Outreach Briefs** — Prospect research and talking points for high-signal conversations
- **Data Tables** — Structured exports (pricing tables, comp sets, benchmarks)

## Top founder workflows on Spine

The highest-leverage tasks founders run end-to-end on Spine — from market truth to investor-ready output.

### GTM plan: ICP + channels + sales process

Execution-ready GTM plan including ICP definition, channel strategy, sales process design, and a 90-day roadmap with milestones and metrics.

_Time saved: 1–2 weeks → 1–2 days_

### Competitive landscape for a new market

Comprehensive landscape across pricing, positioning, features, market share, recent funding, and strategic direction — structured as a comparison matrix + summary.

_Time saved: 3–7 days → 1–3 hours_

### Investor deck: market + comps + projections

Complete fundraising backbone: market sizing, competitive positioning, industry trends, comparable companies, and financial projections — ready to drop into slides.

_Time saved: 1–2 weeks → 1–2 days_

### Market research to decide “commit or pivot”

Problem validation, customer pain points, TAM estimation, competitive dynamics, and business model viability — summarized into a decision memo with clear next steps.

_Time saved: 1–3 weeks → 1–2 days_

### Context-preserving synthesis across ventures

Synthesize information across multiple projects, research threads, and drafts without losing critical context — producing a clean, structured master narrative.

_Time saved: Days of thrash → hours_

### Personalized prospect research + talking points

Personalized research for each investor or client: company dynamics, recent news, competitive position, key stakeholders — plus tailored talking points and outreach angles.

_Time saved: 1–2 hours/prospect → 5–15 min_

## ROI

If you value speed and conviction, Spine pays for itself the first time it saves you a week of uncertainty.

## Frequently asked questions

### Can I use this for real fundraising work?

Yes — Spine is designed for defensible, source-backed research and structured deliverables. You should always review and sanity-check outputs before sending them externally.

### Will it help me avoid “analysis paralysis”?

That’s the goal. Spine produces decision-ready memos and plans with explicit assumptions, trade-offs, and recommended next steps — not just raw research dumps.

### How is this different from ChatGPT or Claude?

Chat interfaces are linear — one question, one answer. Spine runs multiple research agents in parallel on complex requests, with each agent handling a different workstream and passing structured output to the next. The result is a complete deliverable, not a series of text responses you have to paste together.

### Does it use live web sources?

Yes. Agents browse the real web in real-time, cross-reference multiple sources, and resolve conflicting information — not pulling from a fixed training snapshot.


---

# Research and deliverables in minutes, not days.

Canonical URL: https://www.getspine.ai/consultants

Spine saves consultants hours by automating the desk research, the synthesis, and the creation of client-ready deliverables — so your billable hours go toward the work only you can do.

## The most accurate AI research and reasoning on the market.

Consulting deliverables carry your name. DeepSearchQA is Google DeepMind’s hardest benchmark for multi-step research — how well an AI finds, cross-checks, and reasons over real information. Spine ranks #1 ahead of every major alternative, so you get defensible depth, not generic answers.

- **Spine Deep Research**: 87.6%
- Perplexity Deep Research: 79.5%
- Claude: 76.1%
- ChatGPT: 71.3%
- Gemini Deep Research: 66.1%

Source: [Google DeepMind DeepSearchQA](https://blog.getspine.ai/spine-swarm-hits-1-on-gaia-level-3-and-google-deepmind-deepsearchqa/) · 900-question benchmark · February 2026

## What is Spine?

Spine is an agentic platform that leverages 300+ AI models to conduct research, create deliverables, and automate work across all your apps to save you time.

1. **Describe the engagement** — Tell Spine the client brief, the industry, and the deliverable you need. One sentence or a full brief — agents handle either.
2. **Agents go to work** — Multiple agents research simultaneously: competitive landscape, market sizing, regulatory environment, key players. No waiting for one stream to finish before the next starts.
3. **Client-ready output** — Spine produces polished strategy decks, Goldman Sachs-style reports, Excel models, and competitive benchmarks — formatted and ready to send.

## What can Spine do for you?

Spine agents can automate the following workflows for you.

- **Deep Research** — State-of-the-art web agents, cross-referenced across 50+ live sources
- **Strategy Decks** — Polished .pptx presentations, ready to send to clients or partners
- **Reports & Memos** — Goldman Sachs-style documents with citations, structure, and formatting
- **Word Documents** — Full .docx deliverables — briefs, proposals, RFP responses
- **Excel Models** — Real spreadsheets with formulas, multiple sheets, scenario tabs
- **Financial Models** — Revenue projections, unit economics, pricing models, cap table
- **Interactive Dashboards** — Shareable, coded dashboards and data visualizations — live in the browser
- **Competitive Benchmarks** — Structured comparison matrices across any dimension you define

## What consultants build with Spine

Specific workflows consultants run end-to-end on Spine — with structured outputs you can ship.

### Personalized outreach research + talking points

Personalized research on each prospect: company dynamics, recent news, competitive position, key stakeholders — plus prepared talking points for a high-signal conversation.

_Time saved: 1–2 hours → 10–20 min_

### RFP / proposal response: market + competitor positioning

Assemble credible market research, industry data, and competitor positioning to make your proposal stand out — and price with confidence.

_Time saved: 1–2 days → 1–2 hours_

### Recurring competitive intelligence for a retainer

Recurring intelligence on competitor moves, market shifts, and adjacent threats so you can proactively advise clients and justify ongoing retainers.

_Time saved: Manual hours/week → automated_

### Practice growth: pipeline + positioning strategy

Research adjacent verticals, identify ICP signals, and track trends so you can position as a thought leader and win ideal-fit clients.

_Time saved: Days → 1–2 hours_

### Due diligence for investment advisory / founder coaching

Validate market opportunity: TAM/SAM/SOM, competitor capabilities, and regulatory landscape — so you can give confident recommendations fast.

_Time saved: 3–7 days → 2–4 hours_

### Thought leadership: defensible research + formatted output

Cross-reference sources, validate claims, and assemble formatted research for articles, reports, or book chapters — so your work is credible and defensible.

_Time saved: Days → 2–4 hours_

## ROI

If your billing rate is $200–500/hour, Spine pays for itself in it's first hour.

## Frequently asked questions

### Is Spine secure?

Spine is secure and SOC-2 compliant. We use industry-standard encryption and security protocols to protect your data and do not train on your data.

### Is the output actually client-ready, or do I need to clean it up?

Spine produces polished documents, decks, and spreadsheets — not rough drafts. You should always review AI output before sending to clients.

### How is this different from ChatGPT or Claude?

Chat interfaces are linear — one question, one answer. Spine runs multiple research agents in parallel on complex requests, with each agent handling a different workstream and passing structured output to the next. The result is a complete deliverable, not a series of text responses you have to paste together.

### Can it access real web sources, or is it working from training data?

Agents browse the real web in real-time. They navigate data portals, cross-reference sources, and resolve conflicting information — not pulling from a fixed training snapshot.