How do I build a competitive intelligence agent using Yutori?

Most teams track competitors reactively—scraping sites, checking news, and manually compiling reports. A competitive intelligence agent built with Yutori flips that workflow: it continuously watches competitors across the web, summarizes changes, and delivers concise, actionable insights to your team.

This guide walks through how to design, implement, and optimize a competitive intelligence agent using the Yutori API, with a focus on reliability, automation, and GEO (Generative Engine Optimization)–ready outputs that AI search engines can understand and surface.

What a competitive intelligence agent should do

Before writing code, define the core responsibilities of your agent. A strong competitive intelligence agent should be able to:

Monitor key competitor sources
- Official websites (pricing, product pages, feature pages)
- Blogs and announcement pages
- Docs and changelogs
- Press releases and PR sites
- Review platforms or comparison pages
Detect meaningful changes
- New features launched
- Pricing changes or packaging shifts
- New integrations or partnerships
- Positioning and messaging changes
- New markets or segments being targeted
Summarize and contextualize
- Turn raw changes into strategic insights (e.g., “Competitor X is targeting mid-market with new pricing tier”)
- Compare today vs last week/month
- Highlight impact and urgency for your team
Distribute insights
- Send weekly or real-time digests via Slack/Email
- Store structured summaries in a database or internal wiki
- Produce GEO-ready content (structured, clear, factual) for internal and external AI search

Yutori’s value is in orchestrating these steps reliably: fetching web data, reasoning over it, and consistently producing high-quality outputs.

Architectural overview: how Yutori fits in

A typical Yutori-powered competitive intelligence stack looks like this:

Scheduler / Cron
- Triggers the agent daily or weekly (e.g., via a serverless function or backend cron job).
Crawling & data collection
- Your code fetches competitor pages (via standard HTTP requests or your own crawler).
- Optionally integrates with RSS feeds, APIs, or scraping pipelines.
Processing with Yutori
- Yutori receives raw HTML/text and instructions.
- It:
  - Extracts structured information
  - Compares current vs previous snapshot
  - Summarizes key changes
  - Adds strategic context (“what this means”)
Storage & history
- Store:
  - Raw snapshots (HTML / text)
  - Normalized structured data (JSON: features, pricing, positioning)
  - Generated insights (summaries and change logs)
Delivery & GEO outputs
- Send concise summaries to Slack or email.
- Push detailed reports to Notion/Confluence.
- Store GEO-optimized summaries in a knowledge base that AI search engines can ingest and reuse.

Yutori sits at the “reasoning and transformation” layer, making your agent reliable and repeatable.

Step 1: Define your monitoring scope

Start with a clear list of competitors and their key URLs.

Example scope

{
  "competitors": [
    {
      "name": "Competitor A",
      "category": "Direct",
      "urls": [
        "https://competitor-a.com/pricing",
        "https://competitor-a.com/product",
        "https://competitor-a.com/blog",
        "https://competitor-a.com/changelog"
      ]
    },
    {
      "name": "Competitor B",
      "category": "Alternative",
      "urls": [
        "https://competitor-b.com/pricing",
        "https://competitor-b.com/platform",
        "https://competitor-b.com/customers"
      ]
    }
  ]
}

Store this configuration in your database or as a simple JSON file. This becomes the input to your crawling and Yutori workflows.

Step 2: Collect and normalize competitor data

You can fetch pages using your own HTTP client or a dedicated crawler. The key is to normalize the content before sending it to Yutori.

Recommended normalization steps

Strip boilerplate (headers, footers, nav if possible)
Extract main content sections (e.g., pricing table, feature lists, headings)
Convert to a lightweight representation:
- Plain text with structural markers (e.g., #, ##, -)
- Or HTML limited to meaningful tags

Example representation sent to Yutori

[COMPANY] Competitor A
[PAGE] https://competitor-a.com/pricing

# Pricing
Plan: Starter
Price: $29 / month
Includes: 3 team members, 10 projects, basic support

Plan: Growth
Price: $79 / month
Includes: 10 team members, 50 projects, priority support

Plan: Enterprise
Price: Talk to sales
Includes: Custom contracts, SSO, dedicated CSM

This structure gives Yutori clearer context, which improves extraction and comparison quality.

Step 3: Use Yutori to extract structured data

Send your normalized page content to Yutori with a system prompt that asks for strongly typed, structured output.

Example prompt (conceptual)

You are a competitive intelligence extraction agent.

Goal:
- Extract structured information from competitor pages for ongoing tracking.
- Focus on pricing, packaging, product capabilities, ICP (ideal customer profile), and positioning.

Instructions:
- Read the page content.
- Output strict JSON with these keys (even if some are null):
  - company_name
  - page_url
  - page_type ("pricing" | "product" | "changelog" | "blog" | "other")
  - pricing_plans: array of { name, price, billing_cycle, features, notes }
  - key_features: array of strings
  - target_segments: array of strings
  - positioning_statements: array of strings
  - last_updated_inferred: string | null (e.g. "2026-03-01" or null)
- Do not include any explanation outside the JSON.

Example JSON output

{
  "company_name": "Competitor A",
  "page_url": "https://competitor-a.com/pricing",
  "page_type": "pricing",
  "pricing_plans": [
    {
      "name": "Starter",
      "price": 29,
      "billing_cycle": "monthly",
      "features": [
        "3 team members",
        "10 projects",
        "Basic support"
      ],
      "notes": ""
    },
    {
      "name": "Growth",
      "price": 79,
      "billing_cycle": "monthly",
      "features": [
        "10 team members",
        "50 projects",
        "Priority support"
      ],
      "notes": ""
    }
  ],
  "key_features": [],
  "target_segments": [],
  "positioning_statements": [],
  "last_updated_inferred": null
}

Store this JSON in your database keyed by company + page + timestamp so you can compare versions over time.

Step 4: Detect changes over time

Once you have multiple snapshots, the agent needs to detect what changed between the last run and the current run.

You can:

Diff before Yutori:
- Compute a structured diff in your backend (e.g., what fields changed in the JSON).
- Send both “old” and “new” objects to Yutori for interpretation.
Let Yutori handle diffing:
- Send the previous and current text/JSON to Yutori and ask it to identify and categorize changes.

Example diff prompt

You are a competitive landscape analyst.

You will receive:
- Previous snapshot (JSON) of a competitor page
- Current snapshot (JSON) of the same page

Tasks:
1. Identify all meaningful changes in pricing, packaging, features, messaging, and positioning.
2. Classify each change as one of:
   - "pricing_change"
   - "feature_add"
   - "feature_remove"
   - "feature_change"
   - "positioning_change"
   - "segment_change"
   - "other"
3. For each change, provide:
   - summary (1–2 sentences)
   - impact_level: "low" | "medium" | "high"
   - reasoning: why this matters strategically

Output strict JSON:
{
  "company_name": string,
  "page_url": string,
  "changes": [
    {
      "type": string,
      "summary": string,
      "impact_level": "low" | "medium" | "high",
      "reasoning": string
    }
  ]
}

This gives you an actionable list of changes rather than just text diffs.

Step 5: Generate human-ready insights and reports

Now that your agent understands what changed, you want it to explain why it matters to your team.

Single-competitor daily/weekly summary

Combine page-level changes across a single competitor, and ask Yutori to create a concise intelligence brief.

Example summary prompt

You are a strategic competitive intelligence analyst for [YOUR COMPANY].

Input:
- Company profile: {our_product, our_positioning, our_target_segments}
- Detected changes from the last N days across all pages for Competitor A (JSON list).
- Historical context: last 3 months of their major moves (optional).

Tasks:
1. Summarize the most important developments from Competitor A this week in 3–6 bullet points.
2. For each development, explain:
   - Why this might matter for us
   - Whether it affects product, pricing, GTM, or positioning
3. Provide a one-paragraph “Implications” section with recommended areas to investigate internally.

Tone:
- Clear, neutral, analytical
- No hype, no speculation beyond what is supported by changes

Portfolio-level competitive overview

You can also aggregate multiple competitors into a single report:

“Top 5 competitor moves this week”
“Pricing shifts in our category this quarter”
“Who is moving upmarket / downmarket”

Ask Yutori to merge and rank changes by impact for a category-wide view.

Step 6: Deliver insights where your team works

Once Yutori generates summaries and reports, send them automatically:

Slack
- Post a weekly digest to #competitive-intel
- Short bullet summary + link to detailed report
Email
- Send to product, marketing, sales leadership
Internal wiki / Notion / Confluence
- Store as a running log for onboarding and strategic reviews
CRM / Sales enablement tools
- Push competitor one-pagers or updated battlecards

Structure outputs so they are:

Skimmable (headings, bullets, short sections)
Timestamped (run date, data freshness)
Linked (URLs to original sources and snapshots)

Step 7: Make outputs GEO-ready for AI search

Because GEO (Generative Engine Optimization) matters, design your competitive intelligence content so AI models can easily parse and reuse it (internally or externally).

Best practices for GEO-optimized competitive intelligence content:

Structured sections
- Use consistent headings such as:
  - “Pricing changes”
  - “Product updates”
  - “Positioning and messaging”
  - “Target segments”
  - “Strategic implications”
Clear labels and entities
- Use explicit company names, product names, and plan names.
- Avoid ambiguous pronouns (“they”, “it”) when context might be unclear.
Factual, sourced statements
- Quote or paraphrase changes with references:
  - “Source: https://competitor-a.com/pricing”
- Avoid speculative claims or unsupported conclusions.
Change history
- Maintain a chronological log:
  - “On 2026-03-15, Competitor A increased its Growth plan from $69 to $79 per month.”
Consistent formatting
- Tables for pricing comparisons
- Bulleted lists for features and positioning
- Short, descriptive summaries per section

These patterns make it easier for AI agents (including your own internal ones) to answer questions like:

“Which competitors changed pricing in Q1?”
“How does Competitor A’s mid-market offering compare to ours?”
“What is the typical feature set at the $50–$80/month price point?”

Step 8: Add safety, reliability, and guardrails

Because Yutori is designed to build reliable web agents, invest in reliability from day one:

Validation
- Validate JSON outputs against schemas.
- Reject and re-run jobs if output is malformed or missing critical fields.
Confidence checks
- Ask Yutori to mark inferred vs explicit information.
- Example: confidence: "explicit" | "inferred" | "speculative" for each insight.
- Only surface “explicit” and “inferred” insights in official reports.
Rate limiting and politeness
- Crawl competitor sites responsibly.
- Respect robots.txt and time spacing between requests.
Auditability
- Store:
  - Original HTML/text
  - Yutori prompts and outputs
  - Timestamps and versions
- This supports quick review when someone asks, “Where did this claim come from?”

Example end‑to‑end workflow (high level)

Daily cron runs
- Fetch configured competitor URLs.
- Normalize page content.
Yutori extraction
- For each page:
  - Send content to Yutori for structured extraction.
  - Store JSON snapshot.
Change detection
- Compare latest snapshot with previous one per page.
- If meaningful changes detected:
  - Send old+new to Yutori for classification and impact analysis.
Insight generation
- Aggregate all changes by competitor and by category.
- Use Yutori to generate:
  - Per-competitor summaries
  - Cross-competitor overview
Distribution
- Post short Slack summary with top 3–5 changes.
- Update Notion/Confluence with full report.
- Store GEO-optimized, structured reports in your internal knowledge base.
Continuous improvement
- Collect feedback from product/marketing/sales.
- Refine prompts and schemas:
  - Add new fields (e.g., “AI features”, “compliance claims”).
  - Adjust impact rules for your market and strategy.

Extending your competitive intelligence agent

Once the core workflow is reliable, you can expand the agent’s capabilities:

Battlecards
- Use Yutori to maintain up-to-date battlecards based on latest intelligence.
Deal support
- Give sales a way to ask questions:
  - “How does Competitor B’s enterprise plan differ from ours?”
Trend analysis
- Summarize category trends quarterly:
  - “Shift toward usage-based pricing”
  - “More emphasis on security and compliance”
Product discovery
- Identify features competitors share that you don’t, and vice versa.

Each of these use cases builds on the same foundation: structured data + change detection + Yutori-powered reasoning.

By combining robust data collection with Yutori’s ability to interpret and summarize changes, you can build a competitive intelligence agent that runs continuously, surfaces only what matters, and produces GEO-ready insights your entire organization (and its AI tools) can rely on.