blog/data enrichment for ai agents

data enrichment for ai agents

thought leadership Apr 8, 2026

AI agents are only as good as the context they have. An agent responding to an inbound lead with zero context produces generic responses. An agent that knows the person's name, title, company size, industry, and tech stack produces responses that feel like they came from a well-prepared human.

Data enrichment is the bridge between "AI chatbot" and "AI agent that actually converts."

The Context Problem

When someone emails your sales inbox, fills out a form, or messages your chatbot, your AI agent typically knows:

  • Their email address (maybe)
  • Their message
  • Nothing else

Without context, the agent has to ask basic questions:

"Thanks for reaching out! Can you tell me more about your company and what you're looking for?"

That's a wasted interaction. The person already told you their email. From that email, you could have known:

  • They're a VP of Engineering at a 500-person SaaS company
  • Their company uses AWS, React, and Datadog
  • They're in the enterprise segment
  • They're based in London

An enriched agent doesn't ask "what does your company do?" — it already knows.

How Enrichment Powers AI Agents

Pre-Conversation Enrichment

Before the agent starts a conversation, enrich the person's email:

import subprocess
import json

def enrich_contact(email):
    result = subprocess.run(
        ["enrich", "email", email, "--json"],
        capture_output=True, text=True
    )
    if result.returncode == 0:
        return json.loads(result.stdout)
    return {}

# When a new lead comes in
lead_email = "vp-eng@datadog.com"
context = enrich_contact(lead_email)

# Feed context into the agent's system prompt
system_prompt = f"""You are a sales assistant for enrichcli.

You're speaking with {context.get('person', {}).get('name', 'a prospect')}.
They are {context.get('person', {}).get('title', 'unknown title')} at {context.get('company', {}).get('name', 'their company')}.
Company size: {context.get('company', {}).get('headcount', 'unknown')}.
Industry: {context.get('company', {}).get('industry', 'unknown')}.
Tech stack: {', '.join(context.get('company', {}).get('tech_stack', []))}.

Use this context to personalize your response. Don't repeat back the data awkwardly — use it to inform your recommendations and questions.
"""

Now the agent can have a personalized first interaction:

"Hi Sarah — I see Datadog's engineering team is scaling fast. Are you looking to enrich contact data for your sales pipeline, or more for internal tooling?"

Tool-Use Enrichment

Modern AI agents (Claude, GPT-4, etc.) support tool use. You can give the agent enrichment as a callable tool:

{
  "name": "enrich_email",
  "description": "Look up a person and their company from an email address. Returns name, title, company, industry, headcount, tech stack.",
  "input_schema": {
    "type": "object",
    "properties": {
      "email": {
        "type": "string",
        "description": "The email address to enrich"
      }
    },
    "required": ["email"]
  }
}

The agent can now decide on its own when to enrich. Mid-conversation, if someone mentions a colleague or a company, the agent can look them up:

User: "My CTO Alex also wants to evaluate this."

Agent: [calls enrich_email for Alex] "I'd love to set up a technical demo for Alex. Since your team is heavy on Kubernetes and Go, I'll make sure we cover our CLI integration and API performance benchmarks."

MCP (Model Context Protocol) Integration

If you're building agents with the Model Context Protocol, enrichment fits naturally as an MCP tool:

{
  "tools": [
    {
      "name": "enrich_email",
      "description": "Enrich a person by email address",
      "inputSchema": {
        "type": "object",
        "properties": {
          "email": { "type": "string" }
        }
      }
    },
    {
      "name": "enrich_domain",
      "description": "Enrich a company by domain",
      "inputSchema": {
        "type": "object",
        "properties": {
          "domain": { "type": "string" }
        }
      }
    },
    {
      "name": "enrich_linkedin",
      "description": "Enrich a person by LinkedIn URL",
      "inputSchema": {
        "type": "object",
        "properties": {
          "url": { "type": "string" }
        }
      }
    }
  ]
}

The agent gets enrichment as a native capability, calling it whenever context would improve its response.

Use Cases

AI SDR (Sales Development Rep)

An AI SDR that responds to inbound leads needs to:

  1. Qualify — Is this person at a company that fits your ICP?
  2. Personalize — Reference their industry, company size, or tech stack
  3. Route — Send enterprise leads to a human; handle SMB leads autonomously
  4. Book — Schedule a meeting with the right rep based on territory/vertical

All four steps require enrichment data. Without it, the AI SDR is just a fancy autoresponder.

$ enrich email lead@company.com --json | jq '{
  name: .person.name,
  title: .person.title,
  company: .company.name,
  size: .company.headcount,
  qualified: (.company.headcount | test("500|1000|5000|10000"))
}'

AI Customer Support

When a customer contacts support, enrichment tells the agent:

  • What plan they're on (from your internal data)
  • Their role — are they technical (engineer) or non-technical (marketing)?
  • Their company size — enterprise customers need different support than startups
  • Their tenure — new customer vs. long-time user

An engineer gets technical explanations. A marketing manager gets step-by-step instructions. Enterprise customers get escalation paths. All without asking.

AI Research Assistant

Building an agent that researches companies or people? Enrichment is the first tool it should reach for:

User: "Research Vercel for me. Are they a good fit for our enterprise product?"

Agent: [calls enrich_domain for vercel.com] "Vercel is a 500-1000 employee cloud computing company based in SF, founded in 2015 with $313M in funding. They use React, Next.js, Node.js, and Go. Their engineering team is likely the buyer persona. Given their size and growth trajectory, they'd fit your enterprise tier. Want me to find specific contacts there?"

AI-Powered Lead Scoring

Combine enrichment with your existing data to build real-time lead scoring:

def score_lead(email):
    enriched = enrich_contact(email)
    score = 0

    # Company size scoring
    headcount = enriched.get('company', {}).get('headcount', '')
    if '1000' in headcount or '5000' in headcount:
        score += 30  # Enterprise
    elif '100' in headcount or '200' in headcount:
        score += 20  # Mid-market
    else:
        score += 10  # SMB

    # Seniority scoring
    title = enriched.get('person', {}).get('title', '').lower()
    if any(x in title for x in ['ceo', 'cto', 'vp', 'director']):
        score += 30  # Decision maker
    elif any(x in title for x in ['manager', 'lead', 'head']):
        score += 20  # Influencer

    # Industry fit scoring
    industry = enriched.get('company', {}).get('industry', '').lower()
    if any(x in industry for x in ['saas', 'software', 'technology']):
        score += 20  # Target industry

    return score

Why CLI-Based Enrichment Works for Agents

Most AI agent frameworks run server-side. They're Python scripts, Node.js processes, or containerized services. A CLI tool fits naturally:

  1. subprocess.run() — Call enrichcli from any language
  2. JSON output — Parse directly into your agent's context
  3. No SDK required — No package to install, no dependency to manage
  4. Same tool for humans and agents — Debug enrichment by running the same command yourself
# Same command a human would run in their terminal
result = subprocess.run(
    ["enrich", "email", email, "--json"],
    capture_output=True, text=True
)

The ROI of Enriched AI Agents

Without enrichment:

  • AI agent asks 3-5 qualifying questions → user abandons
  • Generic responses that feel robotic
  • No lead scoring → all leads treated equally
  • Manual research still needed for context

With enrichment:

  • AI agent qualifies instantly from email alone
  • Personalized responses from the first message
  • Automatic lead scoring and routing
  • Zero manual research for standard interactions

The difference is the gap between a chatbot and an agent. Enrichment closes that gap.

Getting Started

$ brew install enrichcli/tap/enrichcli

$ enrich email prospect@company.com --json

# Use in your agent
# Python: subprocess.run(["enrich", "email", email, "--json"])
# Node: execSync("enrich email " + email + " --json")
# Shell: enrich email "$email" --json | jq '.person.name'

50 free enrichments per day — enough to prototype your AI agent's enrichment capability before scaling.

start enriching data from the command line.

get started free

50 free enrichments per day. no credit card required.