In one paragraph

An agent needs two things to use external tools: a way to call them and a way to find them. rea and pwc-cli give agents specific capabilities: reverse-engineering a binary or browsing a research catalog. at_mcp gives an agent a persistent social identity on AT Protocol networks. ard-spec sits one level up, defining how agents discover any of these callable resources across federated networks. What counts here: MCP servers, CLIs, and discovery specs that give an agent a capability or let it find one.

The main approaches

MCP servers

A process exposes a set of tools over the Model Context Protocol. The agent calls them by name with structured arguments and gets structured results back. REA drives decompilers and mobile tooling this way. at_mcp wraps AT Protocol operations. pwc-cli doubles as an MCP server over Streamable HTTP alongside its CLI binary.

Agent CLIs

A terminal binary that a human or an automated script can invoke directly. pwc-cli ships a standalone binary for humans that runs the same commands the MCP server exposes. REA also ships a CLI alongside its MCP interface.

Discovery protocols

A specification that defines how callable agentic resources (MCP servers, A2A agent cards, APIs, Skills) are described and found across federated networks of discovery services. ards-project/ard-spec works at this layer, independently of any single tool or domain.

Map of the theme

flowchart LR
  t["Agent tools and protocols"]
  t --> f1["MCP servers"]
  t --> f2["Discovery protocols"]
  f1 --> r1["morluto/rea"]
  f1 --> r2["huggingface/pwc-cli"]
  f1 --> r3["GroveResearch/at_mcp"]
  f2 --> r4["ards-project/ard-spec"]

Where the new ideas are

• rea attaches evidence to every finding and fans out across multiple decompiler backends (Hopper, Ghidra, IDA, JADX) plus JavaScript, .NET, Android, and browser capture from one MCP interface.
• pwc-cli ships a self-generating Skill file alongside the CLI and MCP server, so a coding agent can read the file and know how to invoke the CLI commands without separate documentation.
• ard-spec defines a federated, domain-anchored discovery layer so agents can find callable resources across networks of discovery services.
• at_mcp keeps a write quota and checkpoints in a state directory that persists across runs, so the agent keeps the same AT Protocol account and write budget; it logs in again on each start.

Side by side

Repo	Approach	Protocols / backends	Auth required	Persistent state	Skill / discovery artifact
morluto/rea	MCP servers, Agent CLIs	Hopper, Ghidra, IDA, JADX, adb, Chrome-family browser	Not stated	Not stated	Workflow instructions written by setup
ards-project/ard-spec	Discovery protocols	MCP, A2A, generic APIs, Skills	Not stated	Not stated	CDDL, JSON Schema, OpenAPI schemas
huggingface/pwc-cli	MCP servers, Agent CLIs	Papers with Code API, Streamable HTTP MCP (2026-07-28 and legacy)	Anonymous for reads; login per paper for writes	Not stated	Self-generating Skill file
GroveResearch/at_mcp	MCP servers	AT Protocol (Bluesky, Delvetown), stdio, loopback port	Credentials via env vars	Yes: write quota, checkpoints and (shared service) delivery queue in a configurable directory	Not stated

How the idea moved

flowchart LR
  n1["started Apr 2026<br/>morluto/rea"]
  n2["started May 2026<br/>ards-project/ard-spec"]
  n3["started Jul 2026<br/>huggingface/pwc-cli"]
  n4["started Oct 2026<br/>GroveResearch/at_mcp"]
  n1 --> n2 --> n3 --> n4

• started Apr 2026 · rea · Adds: Routes reverse-engineering work across Hopper, Ghidra, IDA, JADX, adb, and browser capture through one MCP interface, attaching evidence to every finding.
• started May 2026 · ard-spec · Adds: Defines a federated, domain-anchored specification for describing and discovering MCP servers, A2A agent cards, Skills, and APIs across networks of discovery services.
• started Jul 2026 · pwc-cli · Adds: Packs a standalone CLI, a Streamable HTTP MCP server, and a self-generating Skill file into one repo for browsing and editing the Papers with Code catalog.
• started Oct 2026 · at_mcp · Adds: Gives an agent a persistent AT Protocol identity with 43 MCP tools, a local write quota, and state that survives between runs.

Easily confused

Not a general agent framework. These tools do not schedule tasks, manage agent memory, or orchestrate multi-step reasoning. They hand an agent a specific callable capability (a decompiler, a social account, a research catalog) or define the protocol for finding such capabilities. The execution logic lives elsewhere.

Not a model or inference layer. These repos do not run or serve a language model. They sit between a running agent and the external systems it needs to reach.

Not an API gateway. ARD is a discovery specification, not a proxy or rate-limiting layer. MCP servers here expose tools to an agent process; they are not general HTTP gateways for arbitrary clients.

Gaps nobody has filled

• Nothing here covers authentication federation: each MCP server handles credentials its own way, and ARD does not define how a discovery response carries auth hints an agent can act on.
• Nothing here measures tool reliability or latency from the agent’s perspective, so an agent has no standard signal for choosing between two tools that do the same thing.
• The discovery layer (ARD) and the tool layer (the MCP servers) are not connected: no project shows an agent using ARD to locate and then invoke one of the other tools.
• Write safety is handled tool by tool: at_mcp has an hourly write quota and never retries a write with an unknown outcome, and pwc-cli limits edits to one paper for an hour and rejects invalid or stale batches, but nothing here gives destructive or publishing operations a shared approval gate or rollback.
• Nothing here ties tool-signature changes to discovery: ARD entries carry descriptive version and updatedAt terms, and pwc-cli only matches its Skill to its own CLI version, so an agent is not told when an MCP server changes its tools.