What Is the AgentMinds Reporting Profile (ARP)?
Every team building AI agents today emits a stream of telemetry. Errors. LLM costs. Evaluation scores. Recommendations. Each tool collects this telemetry into its own silo: Sentry sees errors but not LLM costs; LangSmith sees agent runs but not security findings; Datadog sees infrastructure but not what the agent actually decided.
More importantly, every team learns its lessons in isolation. When site A's payment-processing agent figures out that GPT-4 occasionally hallucinates currency codes, that lesson stays inside site A. Site B's payment agent re-discovers the same bug six months later, on its own customers, the hard way.
This post is about the gap between those two facts — and the small open specification we wrote to close it.
What ARP is, in one paragraph
ARP — the AgentMinds Reporting Profile — is a JSON schema, a set of conventions, and a collection of small additions to specs that already exist. It defines an envelope for agent reports, a Sentry-aligned lifecycle for warnings, a Langfuse-aligned primitive for evaluation scores, a reverse-DNS extension envelope borrowed from MCP, and one genuinely new primitive: the cross-site learned-pattern lifecycle. The spec is roughly 700 lines of Markdown plus a JSON Schema. It is published under CC-BY-4.0 at github.com/agentmindsdev/profile.
It is explicitly not a new standard. It is a profile — one organisation's documented adoption of five upstream standards plus one extension. We picked that framing on purpose. The next several thousand words are about why.
The problem ARP closes
There are five excellent telemetry formats already in production at scale:
gen_ai.* attribute namespace is now the way to label spans for LLM calls, tool calls, agent operations.Together these five cover almost every shape of telemetry a serious AI agent product would want to emit. Almost.
What none of them have — and what every team running multi-tenant AI agents eventually needs — is a way to express "this lesson, learned on one site, should benefit every other connected site, with privacy intact." That's a primitive. It belongs in a spec.
ARP is what that primitive looks like in JSON.
The cross-site pattern primitive
In ARP §4.1 we define a Pattern object. It has a fingerprint (a stable lowercase hex SHA-256 derived from the agent name plus a normalised pattern description). It has a confidence score, calculated as a Beta-Bernoulli posterior over confirmation events. It has a lifecycle: active while the pattern is currently observed, solved once it's been resolved on enough sites and not re-observed for a freshness window, obsolete when it's been deprecated.
Critically, it has applicable_site_types — a list of site categories where the pattern applies. A learned pattern about React Server Components doesn't apply to a vanilla PHP site. ARP encodes that filter declaratively, so cross-site recommendations don't bombard you with patterns that don't match your stack.
When site A's agent observes a new pattern, the fingerprint is computed and pushed. The collector dedups by fingerprint: if site B independently observed the same fingerprint last week, the confidence rises. If site C's pattern was marked solved two months ago and the fingerprint reappears on site A this week, that's a regression signal that surfaces in both sites' dashboards.
None of the five lineage standards has this. AGNTCY OASF has evaluation_report, but it's anaemic — no confidence aggregation, no cross-site lifecycle. MCP has zero pattern primitive. Sentry has issue grouping, but it's single-tenant. Langfuse has Score, but it's per-trace, not per-pattern.
The Cloudflare Agents docs put it most plainly. Here's a verbatim quote: *"Sub-agents are isolated at the storage level. Each one gets its own SQLite database, and there's no implicit sharing of data between them."* That's a deliberate design choice for Cloudflare. ARP §4.1 fixes the gap that choice creates.
Why a profile, not a standard
We had a choice. We could declare ARP a new standard, recruit signatories, file with a foundation, run a working group. That's what AGNTCY did. That's what MCP did. That's what A2A did.
We chose not to. Three reasons.
First, standards win on adoption, not technical merit. OpenTracing was technically excellent. OpenTelemetry won because CNCF + Datadog + AWS backed it. AgentMinds today has a small footprint. A competing standard from us, no matter how clean, would not move. Tools win on the network effect of the people already using them, and AgentMinds is too early-stage to anchor a network.
Second, standards body work is a separate-company-sized job. Working groups, RFC processes, conformance test suites, version migration documents, public comment cycles, dispute resolution — that's a full-time team. We'd rather build product. Pretending we have the bandwidth to maintain a real standards-body workflow would be a lie to ourselves and to anyone who builds against ARP.
Third, big players will announce competing specs. Anthropic shipped MCP and within six months the rest of the industry adopted it. If a similar primitive appears tomorrow from Google or AWS or Cloudflare, our position must survive that moment without rework. Building a competing standard is the exact opposite of survival — it forces us to defend ground that bigger players will inevitably take.
ARP's strategy is the inverse: be the fastest adopter of whatever standard wins. We follow Sentry + OTel + MCP + Claude Skills + AGNTCY OASF in real time, with an explicit 30-day reorientation clause baked into the spec. If MCP ships notifications/agent/learned, we defer within a month. If AGNTCY OASF v2 absorbs the cross-site pattern primitive, we defer within a month. We are not in the business of owning a competing standard. We are in the business of being the most credible interop layer between everything that already exists.
The 30-day reorientation clause
ARP §7 says: when an upstream standard adopts our pattern primitive, we MUST defer within 30 days. That's not aspirational language. It's enforced by code.
We run a weekly cron called agentminds-standards-watcher. It monitors twelve upstream lineages: MCP, A2A, AGNTCY-OASF, OTel-GenAI, Sentry, Anthropic-Skills, OpenInference, Langfuse, LangSmith, OpenAI-Agents, Cloudflare-Agents, AGNTCY-SLIM. For each, it polls GitHub releases and recent issues for trigger keywords like learned_pattern, cross-environment-fingerprint, findings/list, gen_ai.pattern.*. When any of those fire, the bot files a reorientation-watch issue against agentmindsdev/profile. We have 30 days from that issue to publish ARP MAJOR+1 deferring to the upstream definition.
You can see the current state of those triggers right now: the reorientation-watch label is empty. When it fills up, you'll see ARP morph in real time.
This is the part most "open standards" specs get wrong. They write the spec, declare it open, and never explicitly commit to deprecate themselves when something better comes along. ARP commits in writing, in code, with a public log of the trigger checks.
The privacy boundary
The most common question we get: *"If everyone shares patterns into a pool, can other sites see what my agent learned about my customers?"*
No. ARP defines two tiers explicitly.
Tier 1 is generic web hygiene rules — "missing CSP header", "robots.txt absent", "HTTPS redirect missing". These are public-domain best practices, not learned-from-your-data. AgentMinds publishes 178 of them. You can read them on agentminds.dev/patterns and the slug pages are individually indexed for AI retrieval corpora.
Tier 2 is site-specific learned patterns — "your checkout flow's third retry loops on Stripe webhook 5xx errors", "your auth middleware logs sessions in a way that doesn't meet GDPR retention rules", "your LLM consistently hallucinates currency codes when prompt context exceeds 8K tokens." These are private to your connected site. They are NEVER exposed via public/no-auth API. They are delivered only personalised to YOUR API key.
What other sites see is the aggregate signal from your patterns: confidence rises if multiple independent sites observe the same fingerprint, but the actual content of your pattern is hashed before it leaves your tenant. Cross-site learning happens via fingerprint collision and statistical aggregation, not via raw data sharing.
The fingerprinting is deterministic. Two sites that independently observe the same underlying issue produce the same SHA-256 hash because the normalisation rules strip volatile noise (timestamps, request IDs, percentages, UUIDs) before hashing. Two sites that observe different issues produce different hashes. Confidence rises with cross-site agreement on the same fingerprint, never with content overlap.
How ARP actually works in practice
We support three integration paths, in increasing order of effort.
The first path is for teams that already use Sentry. Your existing Sentry SDK keeps working. ARP collectors accept Sentry's envelope shape directly — the envelope field names overlap closely (event.fingerprint, event.level, first_seen, last_seen, status, breadcrumbs). You point a fork of your event stream at api.agentminds.dev/api/v1/sync/report and you get cross-site recommendations layered on top of your existing Sentry alerts. Zero change to your Sentry setup; ARP is purely additive.
The second path is for teams instrumenting with OpenTelemetry GenAI. ARP's telemetry section is a normative reference to OTel GenAI semconv plus OpenInference v1 attributes. Your spans flow through unchanged; ARP just adds a small agentminds.* attribute namespace for cross-site primitives (agentminds.pattern.id, agentminds.fingerprint, agentminds.confidence, agentminds.cross_site_seen_count). Use the companion package openinference-instrumentation-agentminds (Apache-2.0, on PyPI) to wire it up. The instrumentor is opt-in, attaches to existing OTel SDK setup, and emits one span per agentminds SDK call with OpenInference span.kind=CHAIN.
The third path is for teams writing their own collector. Implement the JSON Schema. You're an ARP-conformant collector at L0 (envelope only) within an afternoon, L2 (cross-site dedup) within a week, L4 (skills + telemetry) within a month. The spec explicitly says you should NOT depend on AgentMinds — competing collectors are good for the ecosystem and good for the credibility of the spec. If a third-party collector ever overtakes us on adoption, that's a win for the open profile, even if it's not a win for AgentMinds the company.
The five-layer identity
ARP claims AgentMinds is simultaneously:
1. An OASF record — discoverable at /.well-known/oasf-descriptor.json per AGNTCY's federation protocol.
2. An A2A agent — discoverable at /.well-known/agent-card.json per Google's Agent2Agent protocol.
3. An MCP server — discoverable at /.well-known/mcp-server.json and reachable via JSON-RPC 2.0 at /mcp/v1/.
4. An OpenInference-instrumented service — when callers install the auto-instrumentation package, every agentminds SDK call emits an OTel span tagged with the OpenInference attribute namespace.
5. A Sentry-pattern compatible collector — accepting fingerprints, levels, statuses, breadcrumbs in the Sentry envelope shape on the ingest path.
No other product ships all five. Ship them all and you make AgentMinds discoverable from every direction in the agent ecosystem: someone walking up via MCP finds it, someone walking up via A2A finds it, someone walking up via OASF finds it. Each surface is a thin descriptor pointing back to the same canonical ARP spec.
We did not have to build five new specs to do this. We built a profile. We adopted five existing specs. We added one primitive. The total amount of new spec text we own is the §4.1 Pattern object plus seven minor extensions in the agentminds_io namespace. Everything else is somebody else's spec, properly cited.
What you can do with ARP today
Read the spec. It's at agentminds.dev/profile with deeper sections on conformance levels, getting started, skill manifests, and adapter mappings. The full Markdown source is in the public profile repo.
Connect a site. The fastest path is pip install agentminds && agentminds connect, and you get an API key + cross-site recommendations within 60 seconds. Your reports flow into the pool, your patterns stay private, your dashboard fills with cross-site recommendations matched to your stack.
Read the deepdive research. We crawled twelve agent-standards in late April 2026 and synthesised the findings into a 12-target comparison matrix plus a 20-action ROI-ranked plan. That document is the load-bearing reference for every spec edit we've made since. It's in the closed-source agentmindsdev/agentminds repo at docs/research/standards_deepdive_2026_04_27/ — happy to share excerpts on request.
Push back. ARP is opinionated; it's also small enough that one of those opinions is probably wrong. The profile repo's issue tracker is open. We're especially interested in feedback from teams already running OTel GenAI, Sentry-style fingerprinting, or AGNTCY-style federation in production — those are the people whose existing infrastructure ARP has to play nicely with.
What ARP does not do
It does not invent a new transport. ARP runs over HTTP POST today; the spec mentions gRPC-over-SLIM as a future binding but doesn't require it. If you want SLIM, AGNTCY's network layer is the right tool.
It does not replace Sentry, Datadog, Langfuse, or LangSmith. They are world-class at single-tenant observability. ARP's value-add is cross-site, which is a different problem. The adapters page on the profile site shows field-level mappings between each of those systems and ARP, so you can run ARP alongside your existing stack without ripping anything out.
It does not solve agent identity. We point at AGNTCY OASF Identity Service for that, and ARP §8 says that L5 conformance (Verifiable Credentials identity binding) is reserved for ARP 2.0. Today every report is authenticated via a shared API key.
It does not solve the open question of how a fast-moving multi-vendor ecosystem coordinates on a primitive. We hope the cross-site pattern primitive ends up in MCP or AGNTCY OASF or Sentry's data schemas eventually. The 30-day reorientation clause exists precisely to make ARP a stepping-stone, not a competitor, to that outcome.
Why this matters now
Agent telemetry is going to consolidate. The Cambrian explosion of vendors — every observability tool announcing AI features, every agent framework announcing its own format, every model lab announcing its own protocol — is not a stable equilibrium. Within eighteen months one of three things happens.
First scenario: one big vendor's format wins and everyone else flips to it (MCP-style). In that world, ARP's reorientation clause means we defer cleanly within 30 days, and AgentMinds becomes an accelerator that gets you cross-site benefits on the winning standard faster than rolling your own.
Second scenario: a foundation-led consensus emerges (AGNTCY-style). In that world, ARP is already cited as a normative reference inside the foundation's spec, and we've contributed our cross-site primitive to the foundation by the time the consensus solidifies.
Third scenario: fragmentation persists for years. In that world, ARP is the interop layer that lets a team adopt one of the five lineages without losing the cross-site benefit. Adapters are first-class citizens; bridges between systems get easier, not harder.
In all three scenarios ARP wins. Not because it's a better standard — it isn't trying to be a standard — but because being the fastest adopter is a position no one else is competing for. Every other player in this space is trying to be the standard. We're trying to be the layer that makes their standard interoperate with yours.
What's next
ARP is at v1.2.1 today. The roadmap is published at agentminds.dev/profile/roadmap. v1.3.0 will wire actual MCP tool delegation (currently the /mcp/v1/ server returns stub responses pointing back to REST), exhaustive OpenInference attribute table, and adapter reference implementations for LangSmith and Langfuse.
We have three open submissions in flight to upstream standards bodies right now: an AGNTCY OASF namespace reservation PR (agntcy/oasf#471), a Model Context Protocol SEP discussion (modelcontextprotocol#2659), and an Anthropic Claude Skills marketplace PR (anthropics/skills#1049). When these merge or close, the ARP roadmap shifts accordingly.
The standards-watcher bot is running. The profile is published. The PyPI package is live. The 5-layer identity is wired. ARP exists. What it becomes next depends partly on us, partly on the upstream standards bodies we follow, and partly on who else builds against it. If you're working in this space, we'd love to hear from you. The repo is public, the spec is open, the issues are tracked.
This is a moment in agent infrastructure where the foundation is still wet. We wrote down our piece of it as carefully as we could, and we made the spec replaceable from day one. If something better comes along, we get out of its way. If nothing better comes along, ARP keeps doing the small useful thing it does. Either way, the cross-site lesson stops being lost.