Skip to main content
GoldenMatch exposes itself as an autonomous entity resolution agent that other AI systems can discover and invoke. An agent says “deduplicate this data” and GoldenMatch handles strategy selection, config generation, pipeline execution, and result explanation — all without human configuration.
Just want to use from Claude Desktop? See the MCP Server page instead — it’s simpler for human-in-the-loop workflows.

What is A2A?

A2A (Agent-to-Agent) is an open protocol for AI systems to discover and invoke each other. Think of it as DNS + HTTP for AI agents:
  1. An agent discovers GoldenMatch at /.well-known/agent.json (like a business card)
  2. The agent card lists skills (capabilities) with input/output schemas
  3. The calling agent sends a task, GoldenMatch processes it, returns structured results
A2A is supported by LangChain, CrewAI, AutoGen, and other agent frameworks. Use A2A when you’re building agent-to-agent workflows where no human is in the loop.

Two Protocols

ProtocolPortBest ForWhen to Use
A2A (Agent-to-Agent)8200AI agent frameworks (LangChain, CrewAI, AutoGen)Agent-to-agent automation, no human in the loop
MCP (Model Context Protocol)stdioClaude Desktop, Cursor, WindsurfHuman-in-the-loop, interactive AI assistants

Quick Start

A2A Server

pip install goldenmatch[agent]
goldenmatch agent-serve --port 8200
Other agents discover GoldenMatch at:
GET http://localhost:8200/.well-known/agent.json

MCP (Claude Desktop)

Add to claude_desktop_config.json:
{
  "mcpServers": {
    "goldenmatch": {
      "command": "goldenmatch",
      "args": ["mcp-serve", "--file", "customers.csv"]
    }
  }
}

Agent Capabilities (31 Skills)

Core & pipeline

SkillWhat It Does
analyze_dataProfile columns, detect domain, recommend matching strategy
configureGenerate optimal YAML config from data analysis (legacy heuristic path)
autoconfigv1.7-v1.12: run AutoConfigController; return committed config + telemetry (stop_reason, decisions, NE / Path Y)
controller_telemetryv1.7-v1.12: surface controller telemetry from the most recent call (stateless A2A dispatch → returns inline note pointing callers at autoconfig / deduplicate inline telemetry)
deduplicateFull pipeline with confidence-gated output, reasoning, and telemetry (v1.7+)
matchCross-source matching with intelligent strategy selection and telemetry (v1.7+)
explainNatural language explanation for any pair or cluster
reviewPresent borderline matches for approval
compare_strategiesRun multiple approaches, report metrics
pprlPrivacy-preserving mode for sensitive data
qualityScan and fix data quality issues (encoding, Unicode, format violations) using GoldenCheck
transformNormalize data formats (phone E.164, dates ISO, categorical spelling) using GoldenFlow

Analysis & operations

SkillWhat It Does
evaluateScore accuracy (precision/recall/F1) against a ground-truth pair CSV
analyze_blockingRank blocking-key candidates: block counts, max block size, candidate-pair totals, estimated recall
compare_clustersCompare two ER outcomes (CCMS / Talburt-Wang Index)
schema_matchAuto-map columns between two files with different schemas
sensitivitySweep config parameters and report clustering stability at each value
incrementalMatch a batch of new records against an existing base dataset
list_runsList previous runs from the run log (for rollback)
rollbackUndo a previous run by deleting its outputs (destructive)

Identity Graph (v2.0)

SkillWhat It Does
identity_resolveResolve a record_id to its durable identity
identity_showFull detail of one identity by entity_id
identity_listList identities, optionally filtered by dataset/status
identity_historyTemporal event log for an identity
identity_conflictsEvidence edges marked conflicts_with
identity_mergeManually merge two identities
identity_splitSplit records off an identity into a new one

Learning Memory

SkillWhat It Does
add_correctionFile a pair- or field-level correction (source=agent, trust 0.5)
list_correctionsPage through stored corrections, filtered by dataset
learn_thresholdsRun the MemoryLearner; return per-matchkey threshold adjustments
memory_statsCorrection counts, last-learned timestamps, current adjustments

How It Works

When an agent calls deduplicate, GoldenMatch:
  1. Profiles the data (column types, cardinality, null rates)
  2. Detects the domain (healthcare, financial, retail, people, etc.)
  3. Selects the best strategy:
    • Strong ID fields (email, SSN) -> exact matching
    • Fuzzy-matchable fields (name, address) -> fuzzy matching
    • Sensitive fields detected -> recommends PPRL
    • Large datasets (>500K) -> recommends Ray backend
  4. Generates a config (matchkeys, blocking, scoring)
  5. Runs the pipeline with confidence gating
  6. Returns results + reasoning

Reasoning Output

Every response includes the agent’s reasoning:
{
  "results": {
    "clusters": 42,
    "match_rate": "8.4%"
  },
  "reasoning": {
    "domain_detected": "people",
    "strategy_chosen": "exact_then_fuzzy",
    "why": "Email has 92% uniqueness -- strong exact key. Name has spelling variation -- jaro_winkler at 0.85.",
    "alternatives_considered": [
      {"strategy": "pprl", "why_not": "No sensitive fields detected."},
      {"strategy": "fellegi_sunter", "why_not": "Fuzzy gives better recall for this data."}
    ],
    "confidence_distribution": {
      "auto_merged": 38,
      "review_queue": 4,
      "auto_rejected": 0
    }
  },
  "storage": "memory"
}

Confidence-Gated Review Queue

Not all matches are equal. The agent splits results by confidence:
ConfidenceActionCount
> 0.95Auto-merged into golden recordsHigh-confidence pairs
0.75 - 0.95Held in review queue for approvalBorderline pairs
< 0.75Auto-rejectedLow-confidence pairs

Storage Tiers

TierConfigPersists?
MemoryDefault (nothing to configure)No
SQLiteCreate a .goldenmatch/ directoryYes (local file)
PostgresSet DATABASE_URL env varYes (shared DB)
The agent auto-detects which tier is available and reports it in every response.

Review Queue API

from goldenmatch import AgentSession

session = AgentSession()
result = session.deduplicate("customers.csv")

# Check what needs review
pending = session.review_queue.list_pending("customers")
for item in pending:
    print(f"Pair ({item.id_a}, {item.id_b}): score={item.score}")
    print(f"  Explanation: {item.explanation}")

# Approve or reject
session.review_queue.approve("customers", 0, 1, decided_by="human")
session.review_queue.reject("customers", 2, 3, decided_by="human", reason="Different entities")

# Stats
print(session.review_queue.stats("customers"))
# {"pending": 2, "approved": 1, "rejected": 1}

Python API

from goldenmatch import AgentSession

session = AgentSession()

# Analyze data and get strategy recommendation
analysis = session.analyze("customers.csv")
print(analysis["strategy"])  # "exact_then_fuzzy"
print(analysis["why"])

# Deduplicate with full reasoning
result = session.deduplicate("customers.csv")
print(result["results"]["clusters"])
print(result["reasoning"]["why"])

# Compare strategies
comparison = session.compare_strategies("customers.csv")
for strategy, metrics in comparison.items():
    print(f"{strategy}: {metrics['clusters']} clusters, {metrics['match_rate']:.1%} match rate")

# Match two sources
matches = session.match_sources("new_customers.csv", "master.csv")

# v1.7-v1.12: explicit AutoConfigController invocation
autoconf = session.autoconfigure("customers.csv")
print(autoconf["telemetry"]["stop_reason"])     # e.g. "green"
print(autoconf["telemetry"]["health"])          # e.g. "green"
for decision in autoconf["telemetry"]["decisions"]:
    print(f"iter {decision['iteration']}: {decision['rule_name']}")

# Telemetry is also cached on `deduplicate` / `match_sources` calls
session.deduplicate("customers.csv")
print(session.last_telemetry)                    # same shape as autoconfigure's telemetry

MCP Tools (16 Agent-Level)

ToolDescription
analyze_dataProfile data, detect domain, recommend strategy
auto_configureGenerate optimal config
controller_telemetrySurface AutoConfigController telemetry (per-session note under stateless dispatch)
agent_deduplicateFull pipeline with reasoning
agent_match_sourcesCross-source matching
agent_explain_pairExplain a pair match
agent_explain_clusterExplain a cluster
agent_review_queueGet pending reviews
agent_approve_rejectProcess review decisions
agent_compare_strategiesCompare ER approaches
suggest_pprlCheck if PPRL is needed
scan_qualityRun GoldenCheck data quality scan, return issues without fixing
fix_qualityRun GoldenCheck scan and apply fixes (safe or moderate mode)
run_transformsRun GoldenFlow transforms (phone E.164, dates ISO, Unicode)
sensitivityParameter-sweep stability analysis
incrementalMatch new records against an existing base dataset
These are additive — existing MCP tools (suggest_config, list_domains, etc.) continue to work. The full MCP surface is 54 tools (16 agent-level + 24 data + 7 Learning Memory + 7 Identity Graph) — see MCP Server.

A2A Agent Card

{
  "name": "GoldenMatch ER Agent",
  "description": "Autonomous entity resolution agent for deduplication, matching, and data quality.",
  "url": "http://localhost:8200",
  "version": "1.26.0",
  "provider": {
    "organization": "GoldenMatch",
    "url": "https://github.com/benseverndev-oss/goldenmatch"
  },
  "capabilities": {
    "streaming": false,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "deduplicate",
      "name": "Deduplicate",
      "description": "Run deduplication pipeline on a single file.",
      "inputModes": ["application/json"],
      "outputModes": ["application/json"]
    }
  ],
  "authentication": {
    "schemes": ["bearer"]
  }
}
Full card at: http://localhost:8200/.well-known/agent.json

Authentication

The server is fail-closed: binding to a non-loopback host (the default is 0.0.0.0) refuses to start unless GOLDENMATCH_AGENT_TOKEN is set. When the token is set, all task endpoints require it as a bearer token; GET /health and the agent card at /.well-known/agent.json stay public for healthchecks and discovery.
export GOLDENMATCH_AGENT_TOKEN="your-secret-token"
goldenmatch agent-serve --port 8200
Binding to 127.0.0.1 runs token-free for local use.
The agent card advertises "streaming": false — task dispatch is synchronous. Poll GET /tasks/{task_id} for long-running skills.

See also

TopicLink
MCP Server (Claude Desktop)MCP Server
Quick start with Python/CLIQuick Start
Full Python API (101 exports)Python API
Configuration referenceConfiguration