GitHub Copilot Agent Finder: What ARD Means for Third-Party AI Tools in 2026

Official Sources

Last updated: June 19, 2026

GitHub shipped Agent Finder on June 17, 2026. Instead of manually configuring which MCP servers, skills, and third-party agents your Copilot instance uses, Agent Finder discovers and invokes the right capability automatically. Describe a task in plain language, and Copilot searches a registry of AI resources, ranks the matches, and pulls in the right tool on demand.

That is not incremental. Agent Finder changes how AI coding tools compose with each other. You no longer wire up every integration by hand. The agent figures out what it needs.

This post covers what Agent Finder actually does, how the new ARD specification behind it works, which third-party agents are available today, and what this means for your workflow.

What Agent Finder Does

Agent Finder is automatic capability discovery for GitHub Copilot. You describe a task, and Copilot searches an index of available AI resources - MCP servers, skills, tools, agents - and returns ranked matches. If a match fits, Copilot loads and invokes it on demand.

The key design choice: Agent Finder does not silently connect anything. It finds the right tool at the right time, shows you the match, and lets you proceed. Manual control stays intact.

Three ways to think about it:

Registry flexibility. Agent Finder works against a registry you choose. Point it at GitHub's curated public catalog, or at your own private registry of internal resources. Enterprise teams can lock discovery to a vetted internal catalog. Solo developers can use GitHub's public catalog and pick up community-contributed tools.

Dynamic composition. Instead of pre-wiring every MCP server and skill into your config, Agent Finder retrieves only what the current task needs. Your agent starts lean and adds capability on demand. That is better for context budget and latency.

Governance integration. Enterprise administrators define which resources agents can discover and use through existing Copilot management settings. Agent Finder respects those policies. You get automatic discovery without giving up control.

The ARD Specification

Agent Finder implements the open Agentic Resource Discovery (ARD) specification. ARD is a standard for publishing, indexing, and discovering AI capabilities - a discovery layer that any registry or AI client can adopt.

Microsoft leads ARD development in partnership with Cisco, Databricks, GitHub, GoDaddy, Google, Hugging Face, Nvidia, Salesforce, ServiceNow, and Snowflake. That is not a small coalition.

How ARD Works

ARD operates like a search engine for AI resources. Developers publish lightweight manifests describing what their resources do. Those manifests get crawled and indexed. AI clients query the index using natural language, and the system returns matching resources along with invocation details.

The difference from traditional search: agentic resources need structured metadata. A manifest describes what the resource accomplishes, when to use it, what inputs it accepts, what authority level it requires, who operates it, how to invoke it, and what policies it complies with. That metadata makes automatic invocation possible.

Registry Architecture

ARD supports multiple discovery services, not a single global catalog. Organizations can establish:

• Public services that index resources across the web.
• Vendor services that expose a single ecosystem's resources.
• Enterprise services that restrict access to internal resources, vetted vendors, and approved third-party capabilities.

Think of it like DNS. You can run your own resolver, join a larger shared system, or do both. Local control coexists with broader participation.

For the technical specification, see agenticresourcediscovery.org.

Third-Party Coding Agents in Copilot

Agent Finder is one part of a broader shift. GitHub now supports third-party coding agents that work asynchronously alongside Copilot's built-in cloud agent. You assign an issue or provide a prompt, and the agent works on changes, creates a pull request, and requests review when finished.

Two third-party agents are available today:

Anthropic Claude - Models include Claude Opus 4.5, 4.6, and 4.7, plus Claude Sonnet 4.5 and 4.6. Auto mode available for automatic model selection.

OpenAI Codex - Models include GPT-5.3-Codex, GPT-5.4, and GPT-5.4 nano. Auto mode available.

Both agents support the same workflow. You can assign them to issues, mention them in pull request comments with @AGENT_NAME, or start tasks from the Agents tab in your repository. They work on GitHub Mobile and in Visual Studio Code.

Enabling Third-Party Agents

Third-party agents require explicit enablement through account policies. When you enable Claude, GitHub installs the "anthropic code agent" GitHub App. When you enable Codex, it installs the "openai code agent" GitHub App.

Both agents are subject to the same security protections as Copilot's cloud agent. Generated code is automatically scanned using CodeQL analysis, secret detection, and vulnerability checks against the GitHub Advisory Database. Security validation does not require a GitHub Advanced Security license.

Billing

Third-party agent usage consumes GitHub Actions minutes and AI credits. If you stay within included allocations on your Copilot plan, there is no additional cost. Heavy users on usage-based billing should monitor credit consumption - agent tasks can burn through credits faster than autocomplete and chat.

For current pricing across all Copilot plans, see the AI coding tools pricing June 2026 breakdown.

What This Means for Your Workflow

If You Use Claude Code or Codex Today

Agent Finder creates a bridge. You can continue using Claude Code or Codex directly in their native surfaces - terminal for Claude Code, Codex CLI or ChatGPT for Codex - while also invoking them from GitHub issues and PRs through Copilot. The agents are the same; the entry points multiply.

That said, the native surfaces still offer features that Copilot integration does not. Claude Code's skill system, CLAUDE.md project config, and subagent architecture run in the terminal, not in GitHub's cloud agent wrapper. Codex's background execution and worktree isolation work best in its native CLI. Copilot integration is useful for GitHub-native workflows like issue triage and PR iteration, not as a replacement for dedicated agent use.

If You Rely on MCP Servers

Agent Finder can discover and invoke MCP servers automatically. If you have been manually configuring MCP servers in .claude/settings.json or similar files, Agent Finder offers an alternative: publish a manifest, register with a discovery service, and let agents find your servers on demand.

For internal MCP servers, the enterprise registry model matters. You can expose internal tools to Agent Finder without publishing them to the public web. Your team's proprietary integrations stay discoverable by your agents and invisible to everyone else.

If You Are Building AI Tools

ARD is open. If you build MCP servers, skills, or agents, publishing a manifest to an ARD-compatible registry makes your tools discoverable by any client that supports the specification - not just GitHub Copilot. Hugging Face's Discover Tool already uses ARD to search across thousands of skills, ML applications, and MCP servers.

Publishing instructions are at agenticresourcediscovery.org/how_to_publish/.

The Bigger Picture

Agent Finder is GitHub's answer to a problem the AI coding market has been circling for a year: how do agents compose with each other without brittle, hand-wired integrations?

The old answer was configuration files. You define which MCP servers your agent can access, which skills it can invoke, which external tools it can call. That works, but it does not scale. Every new capability requires explicit configuration. Agents cannot discover what they do not already know about.

The ARD answer is dynamic discovery. Agents search, rank, and invoke capabilities at runtime. You configure policies - what registries to trust, what resources to allow - but you do not enumerate every tool. The agent figures out what it needs for each task.

That architectural shift has implications beyond GitHub. If ARD gains adoption across the coalition backing it, the same discovery protocol could work across Claude Code, Codex, Cursor, and any future agent that implements the specification. Interoperability becomes possible not through one vendor's integration work, but through a shared standard.

GitHub shipped first. The rest of the market will decide whether ARD becomes the common layer or a GitHub-only feature.

Getting Started

To use Agent Finder:

1. Enable third-party agents in your GitHub account or organization settings. This triggers the GitHub App installations for Claude and/or Codex.

2. Assign an agent to an issue by mentioning @claude or @codex in a comment, or use the Agents tab in your repository.

3. Let Agent Finder discover tools. Describe your task in plain language. If a matching MCP server, skill, or tool exists in your registry, Agent Finder will surface it.

4. Review the pull request. The agent works asynchronously and creates a draft PR with its changes. Leave comments to iterate.

For enterprise teams:

1. Configure agent policies in your organization's Copilot settings. Define which third-party agents are allowed and which registries Agent Finder can query.

2. Publish internal resources to a private ARD registry if you want Agent Finder to discover internal MCP servers, skills, or tools.

3. Monitor usage through existing Copilot usage reports. Agent tasks consume Actions minutes and AI credits.

FAQ

What is GitHub Copilot Agent Finder?

Agent Finder is a feature that automatically discovers and invokes AI resources - MCP servers, skills, tools, and agents - based on natural language task descriptions. Instead of manually configuring every integration, Agent Finder searches a registry of available resources and pulls in what the current task needs. It shipped on June 17, 2026 and is available on all Copilot plans.

What is the ARD specification?

ARD (Agentic Resource Discovery) is an open specification for publishing, indexing, and discovering AI capabilities. Developed by Microsoft, GitHub, Google, Hugging Face, and others, ARD establishes how organizations publish manifests describing their resources and how AI clients query discovery services to find and invoke those resources automatically. The full specification is at agenticresourcediscovery.org.

Which third-party agents work with GitHub Copilot?

Two third-party coding agents are available: Anthropic Claude (Opus 4.5-4.7 and Sonnet 4.5-4.6) and OpenAI Codex (GPT-5.3-Codex, GPT-5.4, GPT-5.4 nano). Both work asynchronously - you assign them to issues or mention them in PR comments, and they create pull requests with their changes.

Does Agent Finder cost extra?

No additional cost if you stay within your Copilot plan's included allocations. Agent tasks consume GitHub Actions minutes and AI credits. Heavy usage on usage-based billing plans will consume credits faster than autocomplete or chat, so monitor your dashboard if budget matters.

Can I use a private registry with Agent Finder?

Yes. Enterprise teams can configure Agent Finder to query private internal registries instead of or in addition to GitHub's public catalog. This lets you expose proprietary MCP servers, skills, and tools to your agents without publishing them publicly.

How does Agent Finder differ from manually configuring MCP servers?

Manual configuration requires you to enumerate every MCP server, skill, and tool your agent can access. Agent Finder discovers capabilities at runtime based on task descriptions. You configure policies (which registries to trust, what to allow) rather than individual tool entries. The agent finds what it needs for each task.

Is ARD only for GitHub Copilot?

No. ARD is an open specification that any AI client can implement. Hugging Face's Discover Tool already uses ARD. If other AI coding tools adopt the specification, the same discovery protocol could enable cross-tool interoperability.

What security protections apply to third-party agents?

Third-party agents are subject to the same security protections as Copilot's cloud agent. Generated code is automatically scanned using CodeQL, secret detection, and vulnerability checks against the GitHub Advisory Database. These protections do not require a GitHub Advanced Security license.

---

Sources

• Agent finder for GitHub Copilot now available - GitHub Changelog, June 17, 2026
• About third-party coding agents - GitHub Docs, verified June 19, 2026
• Introducing the Agentic Resource Discovery specification - Microsoft Command Line Blog
• ARD Specification - Agentic Resource Discovery consortium