Telem

Route agent web searches and inspect the traces.
Route searches across providers, fetch pages clean, observe every step.

Install

curl -fsSL https://docs.telem.ai/install.sh | sh

It sets up the agents it finds on your computer. Keys come from the console; searches show up there too. --dry-run previews. On Windows, run npx @telemai/create@latest in PowerShell. Prefer a skill, MCP, Python, JavaScript, or plain REST? The quickstart walks every path.

Then your agent has it. This is a real opencode run, replayed. The model calls telem_search on its own and sends both angles as one interaction. Then it reads the pages it chose with telem_fetch.

Each of those calls shows up in the console as a session trajectory: every query, the providers that answered, and the pages the agent read. The same two tools work on Claude Code, Codex, OpenClaw and Pi. OpenCode setup →

One call, one format

Two operations do the work, and both answer in the same shape. Many providers answer, and you get one response, with every field in the same place whichever provider supplied it.

Search

Ask once. Several independent search indexes answer at the same time. Every result has the same fields and names the provider that found it.

+ more coming

Pick any subset for each request with providers.include, as in the call below. The Providers table lists the name to use for each.See how every provider's output is normalized →

curl -X POST https://router.telem.ai/v1/search \
  -H "Authorization: Bearer $TELEM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"user_input": {"query": "when was the International Space Station launched"},
       "search": {"providers": {"include": ["exa", "brave"]}, "num_results": 3}}'

The response: a real one, shortened

{
  "status": "succeeded",
  "preprocessor_runs": [
    {
      "preprocessor_name": "exa",
      "output_payload": {
        "tier": "default",
        "results": [
          {
            "rank": 1,
            "url": "https://www.nasa.gov/history/20-years-ago-space-station-construction-begins/",
            "title": "20 Years Ago, Space Station Construction Begins - NASA",
            "summary": "Nov 20, 2018 ... The largest, most complex international construction project in space began..."
          }
        ],
        "latency_ms": 1471
      }
    },
    {
      "preprocessor_name": "brave",
      "output_payload": {
        "tier": "default",
        "results": [
          {
            "rank": 1,
            "url": "https://en.wikipedia.org/wiki/International_Space_Station",
            "title": "International Space Station - Wikipedia",
            "summary": "The ISS is the political product of the development of international cooperation..."
          }
        ],
        "latency_ms": 598
      }
    }
  ],
  "normalized_schema_version": 2
}

Every index answers with the same fields. You write one parser, and a new provider never changes it.

Auto-routing

You do not have to pick the providers. Set auto_routing to "accuracy", and Telem picks them for you: a smart routing technique sends each query to the providers that answer it best.

curl -X POST https://router.telem.ai/v1/search \
  -H "Authorization: Bearer $TELEM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"user_input": {"query": "papers on speculative decoding for LLM inference"},
       "search": {"auto_routing": "accuracy", "num_results": 2}}'

The response: a real one, shortened

{
  "status": "succeeded",
  "routing": [
    {
      "providers": ["perplexity", "brave", "exa"]
    }
  ],
  "preprocessor_runs": [
    {
      "preprocessor_name": "perplexity",
      "output_payload": {
        "tier": "default",
        "results": [
          {
            "rank": 1,
            "url": "https://arxiv.org/abs/2401.07851",
            "title": "Unlocking Efficiency in Large Language Model Inference: A Comprehensive Survey of Speculative Decoding",
            "summary": "[Submitted on 15 Jan 2024 (v1), last revised 4 Jun 2024 (this version, v3)]..."
          }
        ],
        "latency_ms": 1596
      }
    },
    {
      "preprocessor_name": "brave",
      "output_payload": {
        "tier": "default",
        "results": [
          {
            "rank": 1,
            "url": "https://research.google/blog/looking-back-at-speculative-decoding/",
            "title": "Looking back at speculative decoding",
            "summary": "In 2022 we published \"Fast Inference from Transformers via Speculative Decoding\"..."
          }
        ],
        "latency_ms": 589
      }
    },
    {
      "preprocessor_name": "exa",
      "output_payload": {
        "tier": "default",
        "results": [
          {
            "rank": 2,
            "url": "https://arxiv.org/abs/2211.17192",
            "title": "Fast Inference from Transformers via Speculative Decoding",
            "summary": "Fast Inference from Transformers via Speculative Decoding ... Inference from large autoregressive..."
          }
        ],
        "latency_ms": 2595
      }
    }
  ],
  "normalized_schema_version": 2
}

The routing block shows the providers that Telem chose for each query. The installer turns on auto-routing, so the agent plugins use it too. How auto-routing works →

Fetch

Then read the pages worth keeping. POST /v1/fetch takes a list of URLs and returns one document for each URL: the page text, not raw HTML. Its own chain of providers reads the pages, and the first provider that answers wins.

+ more coming

Telem tries them in order until one answers. options.providerspins the chain to a subset. Bright Data (brightdata) is pin-only: it reads LinkedIn records, and Telem never tries it by default.See how every fetch provider's output is normalized →

curl -X POST https://router.telem.ai/v1/fetch \
  -H "Authorization: Bearer $TELEM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://en.wikipedia.org/wiki/International_Space_Station"],
       "options": {"tier": "default"}}'

The response: one document per URL, shortened

{
  "status": "succeeded",
  "preprocessor_runs": [
    {
      "preprocessor_name": "web_fetch",
      "output_payload": {
        "fetched_results": [
          {
            "url": "https://en.wikipedia.org/wiki/International_Space_Station",
            "status": "succeeded",
            "title": "International Space Station - Wikipedia",
            "content": "# International Space Station\n\nThe International Space Station (ISS) is a large space station assembled and maintained in low Earth orbit by a collaboration of five space agencies and their contractors...",
            "content_format": "markdown",
            "content_length": 184213,
            "http_status": 200,
            "provider": "firecrawl",
            "latency_ms": 2184
          }
        ],
        "succeeded_count": 1,
        "failed_count": 0
      }
    }
  ],
  "normalized_schema_version": null
}

A URL that fails does not fail the call. It comes back as its own failed row with the reason, next to the documents that worked.

Full API reference →

Route

One API for many search providers. Pick them for each request, or let auto-routing pick them for each query. Every index’s answers come back in one response.

Fetch

Whole pages as readable content, not raw HTML. Send several URLs in one call to POST /v1/fetch.

Observe

Every search and fetch shows up in the console as a live session trajectory, with judged quality metrics.

Reading this as an AI agent? Start at /llms.txt. It lists every page of these docs and the files written for agents.

Quickstart

Get an API key and make your first search call in a few minutes.

Read the quickstart →

Install for your agent

Add Telem to Claude Code, Codex, OpenCode, Pi or OpenClaw. Each host has a page with the exact install command.

Browse integrations →

API Reference

The full HTTP API: endpoints, requests, responses and error codes.

View API reference →

For AI agents

A machine-readable playbook: when to reach for Telem, how to migrate an existing provider call, and the verified install commands.

Read agents.md →

Was this page helpful?