List companies from the Rivalize universe — the cross-customer competitive-intelligence dataset (not your own tracked competitors; for those use list_competitors).

Search by keyword, filter by category or by which intelligence layer is populated, and paginate.

Args:

• q (string, optional): search name/domain/description

• category (string, optional): category SLUG, e.g. "ai-infra" (names like "AI infrastructure" do not match; each row's categories lists its slugs)

• layer (string, optional): require a populated layer — one of identity, pricing, features, ads, social, reviews, funding_hiring, rankings

• limit (number, optional): page size 1-100 (default 50)

• offset (number, optional): pagination offset (default 0)

Returns compact JSON: { data: Company[], pagination: { total, limit, offset, returned, next_offset }, filters }. Each Company: domain, name, primaryCategory, categories (slugs), priorityScore, lastEnrichedAt, layers (which layers are populated), layersUpdated, description (at most 120 characters). If a page does not fit one response, fewer rows come back with _truncated, and pagination.limit/returned say how many; always continue with offset = pagination.next_offset (null when there are no more). Use get_universe_company for one company's full profile.

Use when: "who are the players in ?" or "show me universe companies matching ".

Get the universe profile for one company by domain, including every populated intelligence layer (identity, pricing, features, ads, social, reviews, funding/hiring, rankings, signals, momentum).

Args:

• domain (string, required): the company domain or any URL on it (e.g. "linear.app" or "https://linear.app/pricing"). Normalized server-side.

• layers (string[], optional): only these layers — any of identity, pricing, features, ads, social, reviews, funding_hiring, rankings, signals, momentum. Asking for fewer layers returns more items of each.

Returns compact JSON: { data: { domain, name, primaryCategory, lastEnrichedAt, layerFreshness, identity, pricing, features, ads, socialInfluencers, reviews, fundingHiring, rankings, signals, momentum, ... } }. Long arrays (recent posts, ad creatives, sources) are capped; _capped lists kept/total for each. If a layer still does not fit, it is left out and listed in _omitted with the exact call that fetches it. The JSON is always complete and valid.

If the domain is not in the universe, says so (and, when the domain is one of your tracked competitors, points at get_competitor_intelligence / get_report instead).

Use when: "give me everything Rivalize knows about ".

Produce a full strategy teardown of one competitor by domain — their positioning/hooks, pricing, ads (the creatives they are running), social presence, reviews, hiring, momentum, plus weaknesses to attack. Returns a ready-to-read Markdown teardown, not raw JSON.

This is the one-call competitor teardown: broader than an ad-only teardown, source-backed, and dated (it leads with when the data was last refreshed). Use it to answer "tear down " or "what is 's strategy and where are they weak?".

Args:

• domain (string, required): the competitor's domain or any URL on it.

Returns Markdown. Ads count as active only if seen in the last 30 days; an unscored momentum is shown as not scored. If the domain is not yet in the universe, says so: when it is one of your tracked competitors it points at get_competitor_intelligence / get_report, otherwise at how to get it enriched.

List the projects in YOUR Rivalize account. A project is one of your products and the competitors tracked against it.

Args: none.

Returns JSON: { data: Project[] }. Each Project includes id, name, url, competitor_count, last_refreshed_at, created_at.

Use the returned project id with list_competitors, list_reports, get_strategic_timeline, get_competitive_landscape, get_freshness and get_evidence.

Use when: "what products/projects do I have?", or first, whenever another tool needs a project_id. (For "which competitors am I tracking?" use list_competitors.)

List the competitive-intelligence reports in YOUR Rivalize account, newest first. Reading is free; this never generates a report.

Args:

• project_id (string, optional): only this project's reports. Call list_projects first for the id.

• limit (number, optional): page size 1-100 (default 20)

• offset (number, optional): pagination offset (default 0)

Returns JSON: { data: Report[], pagination: { total, limit, offset, returned, next_offset } }. Each Report includes id, job_id, project_id, product_name, product_url, competitor_urls, status ("completed" or "unavailable"), created_at, depth ("full" for full research, "quick" for a quick check). A quick check does not buy search traffic, follower counts or the written note on each company, so those are blank in it and marked "Needs full research"; they are not findings.

Use the returned id with get_report.

Use when: "what reports do I have?" or "open my latest report on ".

Read one competitive-intelligence report as Markdown: TL;DR, biggest threat, your blind spots, a section per competitor, and cited battlecards where the report has them.

Claims the report's fabrication check flagged are shown as "[removed — unverified]", exactly as in the report itself. Do not try to fill them in.

Args:

• report_id (string, required): the report id (or its job id) from list_reports

• section (string, optional): only this named section, plus the report title, date and depth, and a line naming the report's other sections. A whole report is several thousand to over a hundred thousand characters and a section is typically a sixth of it, so ask for the section your question needs. Sections: tldr, biggest-threat, blind-spots, actions (what your product should do), battlecards, competitors (every competitor's section in full); per competitor, gathered from every competitor's section: pricing, momentum, app-store, strengths, weaknesses, key-findings, creators, ads, tech-stack. A report has only the sections it has data for. A name that is not one of this report's sections is an error that lists the sections it does have; retry with one of them. Case, spaces and underscores are ignored ("Key findings" = key-findings).

• competitor (string, optional): only the sections whose heading names this competitor (its section and its battlecard), plus the report title and date. Case-insensitive. With section, only that competitor's part of the section (e.g. section "pricing" + competitor "Notion").

• page (number, optional): 1-based page. A report over 25,000 characters is split into pages at section boundaries; every page starts with "Page N of M", the characters that remain, the exact call for the next page, and the sections on later pages. A report that fits is returned whole, unchanged.

Without section, returns the whole report exactly as before. Returns Markdown. 404 if the report is not in your account or is not available.

Use when: "summarise my latest report" (no section, or tldr), "what do competitors charge?" (section "pricing"), "what did the report say about ?" (use competitor).

List the competitors tracked in YOUR Rivalize account (tenant-isolated). Answers "which competitors am I tracking?".

Args:

• project_id (string, optional): only one project's competitors. Call list_projects first for the id.

• limit (number, optional): page size 1-100

• offset (number, optional): pagination offset (default 0)

Returns JSON: { data: Competitor[], pagination: { total, limit, offset, returned, next_offset } }. Each Competitor includes id, project_id, project_name, name, website, threat_level, momentum_score, and brief where the server provides it. Keep paging with offset = pagination.next_offset until it is null.

momentum_score is the rival's momentum score, and threat_level is only that score's band (critical, high, medium, low, or unknown when there is no score): it is not a second assessment, so do not rank by it.

brief, when present, is how the rival stands as your workspace's Brief shows it: brief.standing is "ahead" (the rival is ahead of you), "behind", "even" or "no_read"; brief.standing_label is the Brief's own words; brief.as_of is the date of the report it was read from; brief.state is "read", "not_in_run" (no finished report covered this rival), "no_run", "unreadable" or "deferred" (still being read: the tool asks again a few times before it answers, so a row still "deferred" means call again in a moment).

To pick the "top" or biggest competitor: rank by brief.standing when present ("ahead" first, then "even", then "behind"), otherwise by momentum_score; break ties by highest momentum_score. A rival whose brief.state is not "read" has no standing yet: say so rather than ranking it by standing.

With a competitor's id: get_competitor_intelligence (its latest intelligence), get_battlecard (sales battlecard), get_evidence with its project_id (the sources behind its facts). For what a report said about it: list_reports for the project, then get_report with competitor set to its name. For when it was last observed: get_freshness for its project.

Use when: "which competitors am I tracking?", "who is my top competitor?", or before any per-competitor read.

Get the latest stored intelligence for one tracked competitor.

Args:

• competitor_id (string, required): the competitor UUID (from list_competitors)

Returns JSON: { data: { competitor_name, momentum_score, intelligence, latest_snapshot, source, source_report_id, source_report_date, report } }. source says where the data comes from: "snapshot" (a stored intelligence snapshot), "report" (the competitor's latest report in your account; report holds swot, strengths, weaknesses, key_findings, tech_stack, pricing_tiers, social and reviews, and source_report_id names the report for get_report), or "none" (the competitor appears in no snapshot or report yet). Every field is present only when measured: null or absent means "not measured", not "none". Claims the report withheld as unverified are withheld here too.

Returns a 404 error if the competitor does not belong to your account (tenant isolation).

Use when: "what's the latest intel on ?" after finding its id via list_competitors. For the full narrative, get_report with competitor is richer.

Get the cited sales battlecard for one tracked competitor — Why We Win, Their Weaknesses, Objection Handlers, Discovery Questions. Every claim carries citations resolving to the collected source; claims that could not be cited were WITHHELD, not asserted.

Args:

• competitor_id (string, required): the competitor UUID (from list_competitors)

Returns JSON: { data: { status, sections_empty, sections_locked, withheld_reason?, battlecard, markdown, generated_at, intelligence_date, source, report_id?, report_date? } }.

• status is read off the card's four sections. "ready": every section carries a cited claim. "partial": at least one section has none; sections_empty names them (sections_locked names the ones locked until the user's company profile is complete, which were not withheld). "withheld": the card exists but no section carries a claim; withheld_reason says why. Do not treat "partial" or "withheld" as a complete card.

• "markdown" is a paste-ready cited card and states a partial or withheld card up front. source "generated" is a card generated from the dashboard's Battlecard tab; source "report" is the battlecard inside the competitor's latest report, and report_id names that report (get_report reads it in full).

• status "not_generated": no card can be served — none generated, and the latest report has none (or only one in an older format that fails the citation contract). The user generates one from the dashboard's Battlecard tab.

Requires a Pro-plan API key (403 PLAN_REQUIRED below Pro). 404 if the competitor is not in your account (tenant isolation).

Use when: "give me sales ammo against ", "how do we win vs ", or prepping a call.

Get a receipt-linked timeline of competitor activity across Pricing, Product, People, Funding, and Content/Social lanes.

Args:

• project_id (string, required): the project's UUID. Call list_projects first for the id.

• days ("30" | "90" | "180", optional): history window, default 90

• competitor_id (string, optional): isolate one competitor

• lanes (string[], optional): only these lanes, any of pricing, product, people, funding, content-social

• format ("markdown" | "json", optional): markdown by default (compact); json for the full structure

• page (number, optional): 1-based page of the Markdown. A timeline over 25,000 characters is split at lane/move boundaries; each page says "Page N of M", what remains and the exact next call.

Returns agent-ready Markdown by default (JSON on request) with structured events, seven-day move clusters, tracking-since dates, and evidence URLs. History is never backfilled before Rivalize began tracking. Full history/all-competitor access requires Pro; lower plans can request one competitor for 30 days.

Use when: "what strategic moves have competitors made this quarter?" or "show the arc behind recent competitor activity".

Get the current or stored weekly competitor positions on activity × strategic importance.

Args:

• project_id (string, required): the project's UUID. Call list_projects first for the id.

• week (YYYY-MM-DD, optional): a stored ISO week; omit for current positions. The json format lists stored weeks in availableWeeks.

• format ("markdown" | "json", optional): markdown by default; json for the full structure

• page (number, optional): 1-based page when the Markdown is over 25,000 characters; each page names the next call

Returns agent-ready Markdown by default (JSON on request) with coordinates, trailing signal counts, momentum, latest headlines, importance source, available weeks, and the honest tracking-start date. Historical weeks are never synthesized. History requires Pro; the current view remains available below Pro.

Use when: "who is the biggest moving threat?" or "who moved most this month?".

How current your Rivalize data is for one project: the date of its latest report, and for EACH tracked competitor the date Rivalize last actually observed it and how. Reading is free; this never fetches anything.

Args:

• project_id (string, required): the project's UUID. Call list_projects first for the id.

Returns JSON: { data: { project_id, project_name, latest_report: { id, created_at, depth } | null, competitors: Competitor[], observation_kinds } }. Each Competitor: competitor_id, name, website, status ("observed" or "never_observed"), last_observed_at, last_observed_by, and observations with the newest date of each kind:

• report_run: a report you can read analysed it and its crawl read the site (report_id names the report)

• site_crawl: a stored crawl of its site

• monitoring_page_capture: a monitoring check fetched one of its pages (page_type, url)

• search_check: a monitoring search asked whether anything changed. It does not read the site, so it never sets last_observed_at. last_observed_at is the newest of report_run, site_crawl and monitoring_page_capture, and last_observed_by names which. A competitor nothing has observed is "never_observed" with null dates: no date is ever estimated or filled in, and a record's edit time is never used as an observation date. A failed crawl, a rejected report and a baseline copied from stored data are not observations.

Returns a 404 error if the project is not in your account.

Use when: "how fresh is this data?", "when did we last look at ?", or before relying on a figure, to say how old it is.

The sources behind the facts for ONE subject: your own product (omit competitor_id) or one tracked competitor. Taken from the latest readable report in the project that analysed the subject, as the report serves it: claims the report withholds as unverified are withheld here too, and a figure the report has corrected shows the corrected value.

Args:

• project_id (string, required): the project's UUID. Call list_projects first for the id.

• competitor_id (string, optional): a competitor UUID from list_competitors (it must be in this project). Omit for your own product.

Returns JSON: { data: { project_id, subject: { kind ("product" | "competitor"), competitor_id, name, website }, report: { id, created_at } | null, source_count, unlinked_attributions, off_entity_withheld, sources: Source[] } }. Each Source: url, supports (what it backs: the fact, claim or section, as the report states it), kinds (attribution, page_read, press, strength_receipt, fact, battlecard, interpretation), observed_at (the date of the report run that read it) and, for press, published_at (the article's own date). unlinked_attributions counts data points the report attributed to a description rather than a URL; they are not listed, and no URL is made up for them. off_entity_withheld counts sources a web search for the subject's name returned that are not about the subject (not on its domain, and neither the URL nor any text the report keeps for it names the subject, e.g. a stock page for a similarly named company); they are not listed. With no readable report on the subject, sources is empty and note says why.

Returns a 404 error if the project is not in your account, or if competitor_id is not a competitor in this project (another account's competitor is reported exactly like one that does not exist).

Use when: "where does that come from?", "show me the sources for 's pricing", or to cite a claim.