Use case · AI agents

How AI agents use Velocity for live intelligence

Velocity is built to be the intelligence backend for the agents working for you. A 14-tool MCP server, a commercial REST API, and a live alert stream give your agents watchlists and alerts, momentum briefs, CVE lookups, and threat attribution — natively, with no scraping.

Get an API keyRead the docs
MCP tools
14
MCP tools
read-only, schema-validated
categories
16
categories
micro + macro trends
threat actors
200+
threat actors
MITRE · MISP · CISA
delivery channels
4
delivery channels
MCP · REST · SSE · webhook
Agent playbooks

Six agents you can build on Velocity today

Every playbook maps to real, shipped tools. The tool names below are the exact MCP tools and REST endpoints your agent calls.

Security / DevOpsCVE + GHSA stack matching

An agent that watches your stack and pages you on a new CVE

Point the agent at your repository manifests. It parses them into a tech-stack watchlist, then sits on Velocity’s real-time CVE and GitHub Security Advisory feed. The moment a new advisory matches something you actually run — at the version and variant you declared — the agent gets a hit and can open an incident, file a ticket, or page on-call.

  • security_build_stack_from_fileparse package.json / requirements.txt / go.mod / Gemfile / Cargo.toml into the watchlist
  • security_list_stack_watchread back exactly what the agent is watching + the per-tier cap
  • security_subscribe_stack_hitsone-shot pull of new advisories matched to the stack (Pro+)
  • security_vuln_lookupresolve a specific CVE / GHSA id on demand
Research / AnalystTrend intelligence across 16 categories

A research agent that pulls a momentum brief before you ask

A standing research agent runs every morning, asks Velocity for the top and emerging trends in the categories you care about, and returns an intel brief with the why-now reasoning and cited sources. For a single topic it can pull the full momentum verdict — score, state, and 24h / 7d / 30d windows — so the brief is grounded, not guessed.

  • velocity_intel_brieftop + emerging trends and a category breakdown for a time window
  • velocity_momentum_checkfull momentum verdict for one topic — score, state, windows, why-now, sources (Pro+)
  • velocity_trend_detailsfull detail + recent velocity history for one trend
  • velocity_search_trendssearch by keyword, category, or velocity score
Trading / MarketsMarket & trading signals

A trading agent that reads signals and correlation, not headlines

A markets agent polls Velocity for accelerating market, crypto, and currency trends, checks how a candidate trend’s velocity history correlates with others, and watches its own watchlists for threshold breaches. It reasons over scored signals — sentiment, momentum, volatility — instead of scraping news sites and guessing what matters.

  • velocity_search_trendspull accelerating market / crypto / currency trends by category
  • velocity_correlation_lookupPearson correlation of a trend’s velocity vs. others (Pro+)
  • velocity_watchlist_alertsthreshold breaches on the agent’s own watchlists
  • velocity_momentum_checkconfirm a move with the full momentum verdict (Pro+)
Threat IntelligenceAPT / threat-actor intelligence

A threat-intel agent that attributes and contextualizes activity

A SOC or threat-intel agent looks up adversary groups by name or alias, pulls origin, motivation, and top techniques, and ties activity back to CVE history with confidence-scored evidence. It enriches an alert with attribution context — drawn from MITRE ATT&CK, MISP, and CISA — before a human ever looks at it.

  • threat_actor_lookupresolve one group by name or alias — origin, motivation, top TTPs
  • threat_actor_searchsearch the 200+ group catalog by keyword or attribute
  • security_vuln_lookuppivot from an actor to the CVEs in its history
Retrieval / RAGOpenAI Responses / ChatGPT remote MCP

A ChatGPT or Codex agent using Velocity as a live retrieval source

Velocity ships the canonical search and fetch tools the OpenAI Responses API and ChatGPT remote-MCP ecosystem probe for. Drop the server into a Responses-API tool list or a ChatGPT connector and your assistant cites live, public trend pages directly — no scraping, no stale snapshots, citations that resolve without a Velocity login.

  • searchcanonical retrieval — returns { results: [{ id, title, url, text, metadata }] }
  • fetchcanonical retrieval — fetch one trend by id, returns { id, title, text, url, metadata }
Ops / AutomationCommercial REST API (Bearer vel_* keys)

A pipeline that polls the REST API and fans out to your tools

Not every workflow is an LLM. A plain automation can hit the commercial REST API on an interval — pull active trends or a lightweight pulse — and forward what it finds to Slack, a webhook, or a database. CORS and stable JSON make it a drop-in intelligence feed for any backend.

  • GET /api/v1/trendsactive trends sorted by velocity score, filterable by category + minScore
  • GET /api/v1/pulselightweight latest-point-per-item snapshot for dashboards
Connect

One key, four ways to reach your agents

Pick the channel that fits the agent — the same vel_* key works across all of them.

  • MCP server (Streamable HTTP)

    A single JSON-RPC endpoint at /api/agents/mcp with 14 read-only tools. Native for Claude Code, OpenClaw, and Codex; canonical search/fetch for OpenAI Responses and ChatGPT Developer Mode.

  • Commercial REST API

    GET /api/v1/trends and /api/v1/pulse with Bearer vel_* keys, CORS enabled, per-tier daily quotas, and X-RateLimit-* headers — for agents and backends that prefer plain HTTP.

  • Server-Sent-Events stream

    A live alert stream so an always-on agent reacts the moment a signal crosses a threshold, instead of waiting for its next poll.

  • Email, push & webhook

    The same watchlist + threshold alerts that reach a human can fire a webhook into an agent’s inbox — one alerting layer for people and machines.

velocity-mcp.shbash
# Connect any agent in one command (Claude Code shown)
claude mcp add --transport http \
  --header "X-MCP-Key: vel_your_api_key" \
  velocity https://velocity.andiamo.tech/api/agents/mcp

# Then your agent can call, e.g.:
#   security_build_stack_from_file   → watch your stack
#   security_subscribe_stack_hits    → get new CVE matches (Pro+)
#   velocity_intel_brief             → morning momentum brief
Why agent-native

Scored signals, not raw feeds

Pointing an agent at a pile of RSS feeds means it spends its tokens deciding what is even worth reading. Micro and macro trends across 16 categories, each scored 1–10 on source-trust-weighted reach, acceleration, recency, engagement, and cross-outlet clustering — so you see what is actually accelerating, not just what is loud.

Velocity does that triage before the agent sees anything. Each trend already carries a 1–10 velocity score, a state, a coverage timeline, and cited sources — so your agent reasons over a ranked, deduplicated signal and acts faster on the few things that actually moved.

FAQ

Building an agent on Velocity

The practical questions about auth, tiers, and freshness.

  • How does my AI agent authenticate to Velocity?

    Mint a vel_* API key from the Agent Hub at /agents. The MCP server accepts it as either X-MCP-Key (Claude Code / OpenClaw) or Authorization: Bearer (Codex, OpenAI Responses, ChatGPT). The REST API uses Authorization: Bearer vel_<key>. Velocity stores only a SHA-256 hash of the key — never the plaintext — and every tool call is authorized as the issuing user.

  • Which tools require a paid tier?

    Most MCP tools — including search, fetch, velocity_search_trends, velocity_intel_brief, the security stack-watch tools, and the threat-actor tools — are available on the Free tier. velocity_momentum_check, velocity_correlation_lookup, and security_subscribe_stack_hits require a Pro plan or higher. The commercial REST API (/api/v1/*) requires a Starter plan or above.

  • Can an agent subscribe to alerts for my exact tech stack?

    Yes. An agent can call security_build_stack_from_file to turn your manifests into a watchlist, then security_subscribe_stack_hits to pull new CVE and GitHub Security Advisory matches for exactly what you run, at the version and variant you declared. Velocity matches against a 1000+ entity CPE-aware catalog.

  • Will my agent’s citations resolve for other people?

    Yes. The canonical search and fetch tools return public /trends/<id> URLs, and active trend detail pages are publicly readable. A citation an agent produces resolves in any browser without a Velocity login, so ChatGPT, Codex, and Responses-API answers stay verifiable.

  • How fresh is the data, and how often should an agent poll?

    Velocity scores update on each ingestion cycle. For polling agents, every 5 minutes is plenty for trends and pulse. For reactive workflows, use the SSE alert stream so the agent fires on a threshold breach rather than on a timer. Data delay narrows with tier, from 30 minutes on Free down to real-time on Unlimited.

  • Can I use Velocity data inside my own product?

    Commercial use — embedding Velocity signals in a product you ship to others — is allowed on the Pro tier and above. Lower tiers are for personal and internal use. See the pricing page for the full commercial-use terms.

Give your agents a live intelligence backend

Create a free account, mint a vel_* key in the Agent Hub, and connect your first agent in one command.

Create free accountOpen the Agent Hub