Github Copilot Enterprise

Overview

This page explains how you can integrate GitHub Copilot Enterprise with Akto Atlas to enable agent discovery, centralized guardrails, and enterprise-wide policy enforcement.

As an Akto user, you can secure Copilot Enterprise using two complementary integration layers:

1. Endpoint-level control via Copilot Hooks

2. Model-level control via Akto Agent Gateway (custom model routing)

Together, these provide visibility and enforcement both at the developer endpoint and before requests reach the AI model.

1. Endpoint Enforcement (CLI Hooks)

You can secure Copilot usage using the Copilot Hooks integration (refer to the Copilot Hooks page for complete setup details).

This integration allows you to:

• Monitor prompt submissions

• Block unsafe tool executions before they run

• Send events to Akto Atlas for centralized visibility

This layer secures Copilot usage directly at employee endpoints.

2. Model Routing (Agent Gateway)

To enforce guardrails before requests reach the AI provider, you can configure Copilot Enterprise to route model traffic through the Akto Agent Gateway.

Instead of allowing Copilot to directly access built-in models, you configure a custom model endpoint that points to Akto’s gateway.

Akto then:

1. Inspects and validates the request

2. Applies guardrails and policy enforcement

3. Forwards approved traffic to the configured backend model (Foundry or OpenAI-compatible)

This ensures centralized enforcement across all Copilot Enterprise users.

Prerequisites

Before configuring GitHub:

• Ensure Akto Agent Gateway is deployed and reachable

• Ensure the gateway is connected to:

  • Azure Foundry or

  • An OpenAI-compatible backend

• Validate that the gateway endpoint is functioning correctly

Important

The Agent Gateway must already be connected to the target model backend before you configure it in GitHub. Misconfiguration will cause Copilot requests to fail.

Configuration Steps in GitHub

After completing the prerequisites (including Akto Agent Gateway deployment), perform the following:

1

Go to GitHub → Enterprise Settings

2

Navigate to AI Controls

3

Open Copilot

4

Locate the Configured Models section

5

Disable all default or built-in models (if you want full gateway enforcement)

6

Select Add Custom Model

7

Choose the appropriate provider type:

• Foundry

• OpenAI-compatible

8

Enter the Akto Agent Gateway URL as the model endpoint

• For OpenAI-compatible

  
• For Microsoft Foundry

  

9

1. Save and apply the configuration.

All Copilot Enterprise model requests will now flow through Akto Agent Gateway before reaching the selected backend.

Operational Flow

Once fully configured:

1. User interacts with Copilot

2. (Optional) Copilot Hooks capture endpoint events

3. Copilot sends model request

4. Request is routed to Akto Agent Gateway

5. Akto applies guardrails and validation

6. Approved requests are forwarded to the backend model

7. Responses return through the gateway to Copilot

This provides layered security across the Copilot lifecycle.

Best Practices

• Use both Copilot Hooks and Gateway routing for complete coverage

• Disable direct access to built-in models to avoid bypass paths

• Validate gateway connectivity before enterprise rollout

• Test with a limited user group before full deployment

• Decide your enforcement posture (observe vs block) before enabling strict policies

Get Support for your Akto setup

There are multiple ways to request support from Akto. We are 24X7 available on the following:

1. In-app intercom support. Message us with your query on intercom in Akto dashboard and someone will reply.

2. Join our discord channel for community support.

3. Contact [e-mail] for email support.

4. Contact us here.