Empowering business leaders to scale innovation in the age of AI

Key Concepts

• Agentic Development: A paradigm shift in software development where AI agents collaborate with human developers.
• Custom Agents: Specialized AI agents designed and configured for specific tasks within the software development lifecycle (SDLC).
• Enterprise Grade Agent Ready: A platform designed to meet the demands of enterprise customers, focusing on controls, observability, auditability, and customization.
• Copilot Metrics: Tools and dashboards to track the adoption, usage, and impact of AI tools like Copilot within an enterprise.
• Agent Control Plane: A centralized system for managing, securing, and governing AI agents within an enterprise.
• SDLC (Software Development Life Cycle): The entire process of planning, creating, testing, deploying, and maintaining software.

Agentic Development: A New Chapter for Enterprise Developers

Mario Rodriguez introduces the concept of "Agentic Development" as a fundamental shift in how enterprises work, moving beyond a mere technological transformation to a redefinition of collaboration between human developers and AI agents. This new era necessitates evolved tools that facilitate this collaboration. GitHub's commitment is to provide a platform where developers and agents can meet, observe, propose, and ship software together. To support this, GitHub is delivering enterprise-grade controls, including observability, auditability, and customization, to unlock the next level of enterprise productivity.

The presentation outlines three key areas to be demonstrated:

1. Custom Agents: Transforming the SDLC and collaborating with developers to showcase productivity potential.
2. Metrics: Measuring outcomes and business value delivered by these agent-developer collaborations.
3. Governance: Ensuring trust and enabling agents to operate at scale.

Custom Agents: Revolutionizing the SDLC

Kate, a Copilot PM, highlights Custom Agents as a pivotal feature, designed to address the enterprise need for developers to spend less time on repetitive tasks and more time on creativity and innovation. Custom Agents are purpose-built for specific parts of the SDLC, embedding context, conventions, and toolsets to improve quality and reduce prompting friction. They can be defined at the repository, organization, or enterprise level, baking in security standards, compliance, and organizational values. This allows for the bottling and sharing of expertise across teams, preventing the need to reinvent the wheel.

Examples of Custom Agents:

• Amplitude (Idea to Deploy):

  • Process: An issue is created in GitHub. The Amplitude Custom Agent is assigned to Copilot.
  • Functionality:
    • Opens a Playwright MCP server for generating screenshots (before/after for experiments).
    • Initiates a GitHub MCP Server.
    • Connects to an Amplitude-specific MCP Server to interact with Amplitude.
    • Calls out to Amplitude using its MCP to identify the correct project.
    • Creates a new experiment in Amplitude.
    • Includes a CodeQL run, leveraging years of security product expertise to ensure code safety.
  • Outcome: Generates a fully functional experiment URL, making the experiment live in Amplitude for data tracking. This demonstrates an end-to-end flow from issue to code to verification and deployment.

• ARM Migration (Repository Migration):

  • Process: Demonstrated via the CLI. A repository is opened, and Copilot CLI is initiated.
  • Functionality: The "ARM migration agent" is selected, and the command "migrate this entire repo to be ARM compatible" is issued.
  • Outcome: The agent possesses the expertise to migrate the repository to ARM compatibility.

• Kate's Sparkle Agent (Real-time Creation):

  • Process: Demonstrated in VS Code. A new custom agent is configured.
  • Functionality:
    • Created via configure agents -> create new custom agent.
    • Named "Kate sparkle agent".
    • Pasted markdown instructions.
    • The agent is designed to generate UI elements for an astronomy company, allowing customization of "total stars," "twinkle speed," and "sparkle intensity."
  • Outcome: When prompted with "Create a new HTML file that shows Orion's belt," the agent generates an HTML file that matches the desired UI and can be run locally. This showcases the ease of creating custom agents using markdown, without requiring advanced math or coding knowledge.

• Internal GitHub Agents:

  • Fixit Agent: Used by the docs team to fix problems in the support knowledge base.
  • On-call Buddy: A complex agent that monitors Slack for specific formats during incidents to diagnose issues when the website is down.
  • Shazam Agent: A personal favorite, this agent appends "Shazam!" to every full sentence.

The core message for enterprises is that Custom Agents enable standardization of tools and looks across repositories, making them available anywhere needed.

Measuring the Impact: Copilot Metrics

Todd discusses GitHub's vision to be the home for all developers, especially those in large organizations. His role is to ensure GitHub's AI platform meets enterprise governance, compliance, and security standards. He emphasizes that progress is driven by listening to customer feedback, citing past requests for high availability, enterprise-level teams, and data residency, all of which have been delivered.

Key Deliveries based on Feedback:

• Enterprise Teams: Public preview available, allowing custom teams, roles, permissions, and application management.
• Data Residency: Launched in the EU, Australia, and the US, with thousands of customers already using these stamps.
• FedRAMP Moderate: Committed to, with aims for new regions like Japan in 2026.

Todd then focuses on Copilot Metrics, a crucial tool for enterprises to understand Copilot adoption and impact. This addresses a customer's need to "nail the basics" of adoption and impact on their codebase.

Copilot Metrics Features:

• Dashboard: Provides a quick pulse of usage, including daily and weekly active users.
• User-Level Reports: Downloadable reports that can be rolled up by team or organization.
• Metrics API: For automation and integration with custom dashboards.

Insights Provided by Copilot Metrics:

• Usage: Tracks how many people are using Copilot, daily/weekly active users.
• Chat Activity: Number of chat requests per user, and which features (edit, ask, agent, custom) are most used.
• Detailed Data: Downloadable JSON reports provide granular data by user, IDE, sessions, interactions, features, languages, and models used.
• Organizational Insights: Enables answering questions like:
  • Which teams have high adoption, to learn from their patterns?
  • Which teams have low adoption, to identify needs for prompts, direction, or training?
  • Example: Using Copilot to convert JSON to CSV, then analyzing in Excel to identify the "notifications team" as needing more coaching based on generation and acceptance counts.
• Tech Stack Optimization: Information on models used per language, and acceptance/completion rates per language, to optimize the tech stack. Future capabilities will allow specifying models for custom agents based on language performance.

Future Enhancements: Deeper metrics around proficiency, velocity, output, and impact, along with blending data from other sources for end-to-end visibility.

Governing Agents: Ensuring Trust and Control

Mario returns to discuss trust in agentic development. He frames agents as evolving from tools to collaborators, requiring boundaries, responsibilities, and oversight, similar to physical world security measures like doors, locks, and alarm systems.

Agent Control Plane:

This is a new offering, available in public preview, designed to observe, audit, control, and customize the agent platform. It acts as the governance layer for Agent HQ, where agents reside.

Key Features of the Agent Control Plane:

• AI Controls: A centralized administration area for managing agents.
• Copilot Administration:
  • Access Management: Administering licenses.
  • Content Exclusion: Defining what content agents should not access or process.
  • Configure Allowed Models: Specifying which AI models (e.g., GPT-4.5, Opus) can be used by agents.
  • Editor Preview Features: Managing preview functionalities.
  • Metrics and Billing: Integrated visibility into usage and costs.
• Agent Management:
  • Installed Agents: Future agents (like Codex, Claude Code) will appear here and can be enabled across the organization.
  • Custom Agents: Management of agents created by users, as demonstrated by Kate.
  • Activity Log: A single pane of glass showing all agent and developer activity across the enterprise. This includes agent sessions and Git events (e.g., pull requests created).
  • Export Functionality: Ability to export activity logs and Git events for auditing.
• Setting Standards for Custom Agents:
  • Enterprise Standards: Ability to define and enforce standards for custom agents across the entire enterprise with a single click.
  • Availability Control: Making specific custom agents available or unavailable to all developers.
  • Rule Sets: Editing rule sets to control who can make changes to agent files (e.g., only enterprise owners).
  • Approval Workflow: New agents can be added via pull requests, requiring approval from enterprise owners.
• Agent Sessions Monitoring:
  • Mission Control View: Provides visibility into agent sessions across the enterprise.
  • Teleportation to Session: Ability to open an agent session directly in VS Code Insiders for immediate inspection and intervention.
• Developer Administration: The control plane allows for administering both agents and developers, including revoking licenses or permissions.

Mario emphasizes that the goal is to enable collaboration between developers and agents, increase productivity, and accelerate innovation. The core primitives of agents, metrics, and governance will be continuously extended.

Conclusion: The Evolving Garden of Software Development

The presentation concludes by reiterating that this future is not distant; it's happening now. GitHub itself is an example, with its coding agent being the number one contributor. The SDLC is no longer static but an evolving "garden" where best practices, new tools, and ways of working emerge. Agentic development, supported by GitHub's platform, is poised to redefine work chapters, drive developer productivity, foster stronger teams, and deliver significant value across the enterprise. The overarching message is one of continuous collaboration and building together.