company_detail
ChatGPTFull data for ONE section of a single company (name or domain). This is the FULL list behind a company_profile count; for a quick overview of all sections at once use company_profile instead. Sections: `'tech'` — the complete detected technology stack, ordered by global adoption. Returns the full stack in one call (offset/limit do not apply); summarise large stacks by category rather than listing every item. The list is complete — do not caveat about undetected tech. 'jobs' — paginated job postings (up to 150 per call). Response has total_jobs and has_more; only page again with a higher offset when has_more is true, and only if the answer genuinely needs more rows — summarise large job sets (by department / seniority / title theme) instead of paging them all. * 'partners' — paginated partner companies. Response has total_partnerships and has_more. Some companies have THOUSANDS of partners; never page through them all (each returned partner is a billed company record). Report total_partnerships, show the first page, and for the full set offer a saved list instead (lists_edit action='create' with a partner_of leaf) — the user can browse it in the app. To test ONE technology against a company use company_uses_technology; to test ONE partnership edge use company_partnered_with — both are cheaper than pulling a whole section and scanning it. Args: company: The company's name or domain (e.g. "Stripe" or "stripe.com"). section: 'tech', 'jobs', or 'partners'. offset: Pagination offset for 'jobs' / 'partners' (default 0). limit: Max rows for 'partners' (default 20, max 100). Ignored by 'tech' (full stack) and 'jobs' (fixed page of 150).
company_partnered_with
ChatGPTYes/no: are two companies partners? Confirms a single partnership edge ("is Stripe partnered with Shopify?") instead of paging the full partner list with company_detail (section='partners') and scanning it. The relationship is undirected — argument order doesn't matter. Each argument is a company NAME or DOMAIN and resolves on its own — no need to look up domains first. Returns partnered (boolean) plus evidence (first/last seen and observation count, or null when not partners), and echoes the resolved identity of each company. Args: company: One company's name or domain (e.g. "Stripe" or "stripe.com"). partner: The other company's name or domain (e.g. "Shopify").
company_profile
ChatGPTLook up companies by name or domain — start here for any company question. company_profile is the SUMMARY: identity, firmographics, section COUNTS, and a small sample of tech / partners (jobs are count-only here). For the FULL list behind any count — the complete tech stack, the job listing, the partner list — call company_detail with the matching section ('tech' / 'partners' / 'jobs'). A profile may also include related_companies — corporate ownership context (parent / subsidiary / acquirer / acquisition / division); absent when no ownership relationships are known. Reach for a point tool instead of a full profile when the question is a single fact: "does X use tech Y?" → company_uses_technology; "who uses Y?" → find_companies_using_technology; "are X and Y partners?" → company_partnered_with. To discover companies matching partnership + other criteria, use find_companies with a partner_of leaf. Args: inputs: Company names or domains (max 5). A name resolves to its canonical company; ambiguous names return candidate matches.
company_uses_technology
ChatGPTYes/no: does ONE company use a specific technology or vendor? Use this to confirm a single fact ("does Shopify use Snowflake?") instead of pulling the company's whole stack with company_detail (section='tech') and scanning it yourself. The technology argument is fuzzy-matched the same way as find_companies_using_technology; the response echoes a matched block showing which technology/vendor it resolved to — check it before trusting the verdict. Returns uses (boolean) plus evidence (detection stats, or null when not used). When a name is both a technology and a vendor (e.g. "Salesforce") it returns ambiguous: true with both candidates — re-run with kind. If technology doesn't resolve to anything, returns error_code not_found — do not invent a yes/no. Args: company: The company's name or domain (e.g. "Shopify" or "shopify.com"). technology: Technology name, exact tech key, or vendor name (e.g. "Snowflake", "google-analytics", "Salesforce"). kind: "auto" (default) resolves either type and disambiguates a name that is both; "technology" or "vendor" forces that type.
find_companies
ChatGPTDiscover companies matching a combination of criteria — the compound questions the single-purpose tools can't answer: "uses both X and Y", "X but not Y", "customers of X also using Y", "partners shared among X, Y, Z", "which of these domains use Z". Returns a match COUNT plus a small sample (the count is free signal; only the sample is billed), then offers to save the result as a live list. definition is a boolean tree of filter leaves — pass a bare tree or {"query": <tree>}. Call lists_filter_fields FIRST: it returns the available fields (technology / vendor / job_title / partner_of / firmographics / __domains), their operators and value shapes, AND an authoring guide for the tree grammar (GROUP/LEAF shape, AND-vs-OR value semantics, negation, the "one leaf per required technology" rule, and the mandatory positive filter). Author the tree from that guide rather than guessing the shape. Two recurring traps the guide covers: a leaf's value list is OR, so requiring several technologies TOGETHER needs a separate in leaf for each; and a pure-negation query ("neither X nor Y", "not using Z") has no positive anchor and is rejected — don't invent a number, tell the user it needs a positive criterion. Pick the leaf by what the request MEANS: "uses / customer of <vendor or tech>" is a technology/vendor leaf; "partner of <company>" is a partner_of leaf — a vendor's customers are not its partners, so never substitute one for the other. Company-valued leaves (partner_of, __domains) take domains — resolve a company name to its domain with company_profile first. For a SINGLE technology or vendor ("who uses Snowflake?") use find_companies_using_technology — it needs no tree. This tool is for combinations across two or more criteria.
find_companies_using_technology
ChatGPTFind the companies that use ONE specific technology or vendor. Pass any technology or vendor name (it fuzzy-resolves); the matched block returns the stable tech_key / vendor_slug to reuse as a find_companies leaf. For a COMPOUND query (and/or/not across multiple criteria — "uses X and Y") use find_companies instead. To browse WHICH technologies exist (not their users) use technology_catalog. When a name is both a technology and a vendor (e.g. "Salesforce"), the tool returns ambiguous: true with both candidates instead of guessing — re-run with kind="technology" or kind="vendor" to choose. If it returns error_code: not_found, the entity isn't available — say so and stop; do NOT substitute a different leaf type. Popular technologies have tens of thousands of users; never page through them all (each returned company is a billed record). Report the free total_companies count with the first page, and for the full set offer a saved list instead (lists_edit action='create' with a technology/vendor leaf) — the user can browse it in the app. Args: query: Technology name, exact tech key, or vendor name. limit: Maximum companies (default 20, max 50). offset: Pagination offset (default 0). kind: "auto" (default) resolves either type and disambiguates a name that is both; "technology" or "vendor" forces that type.
flag_company_data
ChatGPTFlag a company's Trace data as wrong and queue it for review. This is an additive write: the company is queued for data-quality audit, but no company data is changed by this tool. The domain may be in any common form (a URL, a www. host, or with a path), and the response echoes the company that was flagged. Args: domain: The company's domain (e.g. "stripe.com"). description: Optional user-authored context about what looks wrong.
lists_admin
ChatGPTDestructive / ownership list operations. Confirm with the user before calling unless their message already authorizes the exact change. action='delete' — delete the list and CASCADE its rules/permissions/ members. Owner or org-admin only. action='transfer' (requires new_owner_user_id) — transfer ownership. Owner only (no org-admin override). action='remove_domain' (requires domain) — remove a domain from the list AND blacklist it so a later recompute can't resurrect it. Use lists_edit action='unblock' to later lift the blacklist. action='grant_permission' (requires role plus one of grantee / org_wide=True) — grant 'editor' or 'viewer' access. grantee is the person's NAME or EMAIL; it's resolved to a member of the caller's org. Just ask the user for a name or email — never ask for a user id or Auth0 sub. If the name matches several members the tool returns candidates to pick from; if it matches nobody in the org, tell the user that and offer org-wide. action='revoke_permission' (requires permission_id) — revoke a grant. Editor-or-higher access to the list is required. Args: action: 'delete', 'transfer', 'remove_domain', 'grant_permission', or 'revoke_permission'. list_id: The numeric list_id (required for all actions). domain: Required when action='remove_domain'. new_owner_user_id: Required when action='transfer' (Auth0 sub). role: Required when action='grant_permission' ('editor' | 'viewer'). grantee: The name or email of the person to share with (grant_permission); resolved to an org member. Omit when org_wide=True. user_id: Rarely needed — a raw Auth0 sub for programmatic callers that already have one. Prefer grantee. A raw email/name is rejected. org_wide: Grant to every org member (grant_permission only). permission_id: Required when action='revoke_permission'.
lists_edit
ChatGPTNon-destructive list edits. action='create' (requires name) — create a list. Pass definition (a full envelope {schema_version, registry_version, query}) when the user describes the list by CRITERIA ("companies using Salesforce") so membership stays current; call lists_filter_fields for the leaf shapes. Omit definition only for a genuinely empty list. Optionally pass columns to set the initial visible columns; otherwise Trace uses narrow defaults plus smart columns from the criteria. Confirm in plain words; never print the list URL or id (the UI shows a "View list" button). action='update' (requires list_id) — patch metadata only (name / description). Does NOT change the definition; use lists_set_definition for that. action='copy' (requires list_id, name) — save a visible list as a new user-owned list. Copies the active definition and, by default, the source columns but not permissions/audit/history. action='update_columns' (requires list_id, columns) — replace the ordered visible-column config. Pass expected_config_version from lists_read(action='get')/GET columns when available to avoid overwriting a concurrent edit. action='add_domains' (requires list_id, domains) — add specific named domains to the static include set. Use ONLY when the user names companies; for CRITERIA author a dynamic rule via lists_set_definition instead. action='unblock' (requires list_id, domain) — lift a domain's blacklist (does not re-add it to the include set). action='materialize' (requires list_id) — force-rebuild the member set right now by rerunning the filter query, bypassing the scheduled refresh. Use when the user says "refresh the list", "rebuild membership", "recompute now", "force update", or wants current results immediately rather than waiting for the next automatic refresh. Editor-or-higher access required for 'update' / 'update_columns' / 'add_domains' / 'unblock' / 'materialize'. View access is sufficient for 'copy'. Args: action: 'create', 'update', 'copy', 'update_columns', 'add_domains', 'unblock', or 'materialize'. list_id: Required for every action except 'create'. name: Required when action='create'; optional patch when 'update'. description: Optional free text (<=4096 chars). definition: Optional definition-tree envelope for action='create'. columns: Optional column config for 'create' or replacement columns for 'update_columns'. expected_config_version: Optional optimistic concurrency token for 'update_columns'. copy_columns: Whether 'copy' should copy source columns (default true). materialize: Whether 'copy'/'materialize' should build members now. domains: Domains to add when action='add_domains'. domain: Domain to unblock when action='unblock'.
lists_filter_fields
ChatGPTList the fields you can use in a list definition tree. Call this before authoring a definition with `find_companies / lists_set_definition / lists_edit (action='create') so a request like "all companies using Salesforce" becomes a dynamic, self-updating rule rather than a frozen set of explicit domains. The response carries: * fields — the same registry the builder UI reads: each rule-leaf field (e.g. vendor, technology, partner_of), its allowed operators, and its value shape. * registry_version — copy it into the envelope you author rather than guessing a value. * authoring` — the tree grammar: GROUP/LEAF shape, snake_case operators, the OR-within-a-leaf rule (and how to require multiple values together), negation forms, the mandatory positive filter, and a worked example.
lists_members
ChatGPTReturn the current materialization of a list, paginated. Args: list_id: The numeric list_id. limit: Max members per page (default 100, max 500). offset: Pagination offset (default 0). tier: Filter to one band: 'high', 'medium', or 'exploratory'. force_refresh: If true, synchronously recompute before returning.
lists_read
ChatGPTRead saved lists. action='all' — every list the caller can see (owned, granted, or org-wide); also auto-creates the org's default "Target Prospects" list on first call if missing. No other args. Each list carries is_owner and access_level ('owner'/'admin'/'editor'/'viewer') — use them to answer "my lists" (is_owner=true) vs. lists merely shared with the caller, and to know which the caller may delete/transfer. action='get' (requires list_id) — one list's definition tree + permissions summary. include folds in detail sections: 'audit', 'materialization_history', 'excluded_domains'. Unknown include keys are rejected. action='find_by_domain' (requires domain) — the visible list_ids that already contain domain as a materialized member. Use before adding a domain to detect duplicates. For the paginated member SET of a list use lists_members; for the fields available in a definition tree use lists_filter_fields. Args: action: 'all', 'get', or 'find_by_domain'. list_id: Required when action='get'. domain: Required when action='find_by_domain'. include: Optional detail-section keys for action='get'.
lists_set_definition
ChatGPTReplace a list's ENTIRE definition with `definition. definition is a full definition-tree envelope {schema_version, registry_version, query} — the nested boolean filter tree the builder edits. This is a wholesale replace, not a merge: to make a small change, fetch the current tree first (lists_read action='get' returns it under definition), edit it, and pass the whole edited tree back. The envelope is validated server-side (strict) — a malformed tree or one with no positive predicate is rejected. A successful call appends a new immutable version and bumps definition_version (invalidating the materialization cache); the next lists_members recomputes. This is how you build a list from CRITERIA — "companies using Salesforce", "customers of vendor X", "uses technology Y" — as a vendor / technology rule leaf that re-evaluates every materialization, so membership stays current. Call lists_filter_fields first to learn the leaf fields and value shapes; resolve a vendor/tech name to its vendor_slug / tech_key with find_companies_using_technology. Only for adding/removing a few explicitly-named companies should you prefer lists_edit (action='add_domains') / lists_admin` (action='remove_domain') instead. Editor-or-higher access required. Args: list_id: The numeric list_id. definition: The full definition-tree envelope to install.
target_generate
ChatGPTGenerate a ranked list of target companies for a given domain. Two modes via `target_kind: * "customers" (default) — find companies that look like the *customers of* the requester. Use this for "who could I sell to?" The engine pulls customers from tracked-vendor evidence, the uploaded_customer_list if supplied, or a peer-vendor bootstrap as a last resort. Always produces a well-formed result for any valid domain. * "self" — find companies that look like the requester ITSELF (and any additional companies in uploaded_customer_list, which in self-mode are treated as ADDITIONAL seed companies — not customers). This is PEER discovery: companies similar to the seed by industry, size, and footprint ("who else looks like Crossbeam?"). Competitors are one kind of peer that surfaces — not the whole result; expect look-alikes broadly (peers and adjacent players), not a curated competitor set. Don't describe the output to users as "competitors". The seed (requester + uploaded list) is excluded from output. When the requesting domain is unknown to us, returns error_code="requester_unknown_use_authenticated_api" (the MCP runtime can't auto-trace — read-only DB / no SQS perms). The agent should ask the user to look up the domain in the Trace UI or run a trace through the authenticated REST API, then retry. Returns up to max_count candidates, each scored 0-1 and tagged with a confidence band (HIGH / MEDIUM / EXPLORATORY). Optional min_band quality floor turns max_count into a soft cap: "give me up to N candidates AT OR ABOVE this band — don't pad with weaker matches." Output is a preview — nothing is persisted; every call writes a telemetry row to lookalike_generation_runs. Callers should check diagnostic.overall_coverage to decide how much to trust the result. Args: requesting_domain: Domain of the company generating the list (required). industries_include: Keep only candidates in these IndustryBucket values. industries_exclude: Drop candidates in these IndustryBucket values. employee_range_include: Keep candidates only in these employee range buckets (e.g. ["51-200", "201-500"]). countries_include: ISO 3166-1 alpha-2 codes to include. countries_exclude: ISO 3166-1 alpha-2 codes to exclude. exclude_domains: Explicit domain blacklist. uploaded_customer_list: In customers-mode, customer domains used as the seed when the requester isn't a tracked vendor. In self-mode, additional seed companies that (with requesting_domain) define the "look like THESE" template. max_count: Maximum candidates returned. Default 100, max 500. target_kind: "customers" (default) or "self". min_band: Optional quality floor — "high", "medium", or "exploratory"`. When set, max_count is a soft cap.
technology_catalog
ChatGPTSearch the technology/vendor CATALOG by name — "what analytics tools exist?". This browses the catalog of technologies and vendors Trace can detect; it does NOT tell you which companies use them. To find the COMPANIES that use a technology use find_companies_using_technology. Returns matching catalog rows with the stable tech_key / vendor_name you can reuse as a find_companies leaf value. Args: query: Search term (technology or vendor name). limit: Maximum results (default 20, max 50). offset: Pagination offset (default 0).
company_detail
Claudecompany_partnered_with
Claudecompany_profile
Claudecompany_uses_technology
Claudefind_companies
Claudefind_companies_using_technology
Claudeflag_company_data
Claudelists_admin
Claudelists_edit
Claudelists_filter_fields
Claudelists_members
Claudelists_read
Claudelists_set_definition
Claudetarget_generate
Claudetechnology_catalog
Claude