When Microsoft Copilot fails, the cause is almost always one of four things: a license or tenant policy that silently withholds the feature, a network path blocked by a proxy or firewall, a browser or client state problem, or a service-side outage. Copilot rarely breaks in isolation. The client, the identity layer, and the service must all agree before a prompt returns an answer.
This holds whether you mean Microsoft 365 Copilot, GitHub Copilot, Windows Copilot, or a third-party assistant. The labels differ, but the failure surface is remarkably consistent. Understanding that surface turns a vague "it's not working" into a testable hypothesis.
What the client actually sends when you press enter
A Copilot prompt is not one request. It is a chain of authentication, policy evaluation, content filtering, model routing, and grounding steps. A failure at any link returns the same generic error to your screen.
The client first obtains a token from the identity provider. It then sends your prompt, plus context from the open document or repository, to a service endpoint. The service checks your license and tenant policy. It filters the prompt for prohibited content. It routes the request to a language model. Finally, it grounds the answer in your organizational data if the product supports that.
Each step has its own timeout. GitHub Copilot's editor extension, for instance, requests completions over HTTPS to a dedicated endpoint and expects a response within a short window. If the token is stale or the endpoint is unreachable, the extension silently stops suggesting rather than showing a hard error. That silence is why "it just stopped" is the most common complaint.
The plain version: think of Copilot as a relay race, and any runner can drop the baton without announcing it.
Where the request chain habitually breaks
Quantified failure rates are hard to source reliably, so treat the following as mechanism classes rather than measured proportions. Field support patterns consistently point to a small set of recurring causes.
Licensing and entitlement gaps dominate Microsoft 365 Copilot failures. The product requires an assigned license, and many tenants pilot it to a subset of users. An unlicensed user may see the Copilot button but receive a policy-blocked response, which looks like a bug and is not one.
Authentication token expiry is the second frequent cause. Access tokens typically live about an hour. A device that slept overnight, or a session that crossed a conditional-access re-evaluation, can hold a token the service rejects. The client usually refreshes silently, but a blocked refresh (expired password, revoked session, changed MFA method) produces a working-looking interface with failing requests.
Network inspection is the third. Enterprise proxies and TLS-inspecting firewalls occasionally break the streaming connections Copilot relies on. GitHub documents that Copilot needs outbound HTTPS to specific hosts, and a proxy that terminates or buffers those connections can stall completions while leaving the rest of the web functional.
Client state is the fourth. A corrupted extension cache, an outdated editor build, or a browser profile with conflicting extensions produces failures that vanish after a clean reinstall or a fresh profile. This is the cause most often misdiagnosed as a service outage.
Timeline: how a single failed Copilot request unfolds
| Stage | Typical timing | What can go wrong |
|---|---|---|
| Token acquisition | Under 1 second | Expired credentials, revoked session, MFA challenge |
| Policy and license check | Under 1 second | Missing license, tenant setting disabled |
| Prompt filter | Under 1 second | Content flagged, request rejected |
| Model routing | 1-5 seconds | Capacity throttling, region outage |
| Grounding (if enabled) | 2-10 seconds | Index stale, permission mismatch |
| Response streaming | Variable | Proxy buffering, connection reset |
The table is a diagnostic map, not a guaranteed schedule. Timings vary by product and network. But the ordering explains a useful rule: if the spinner appears at all, authentication and policy likely passed, and the fault sits later in the chain.
Outages, throttling, and the capacity ceiling
Service-side failures are real but rarer than users assume. Providers publish status pages, and a regional outage will affect many users at once. The distinguishing signal is scope: one user failing points to the client, while a whole team failing at the same minute points to the service.
Throttling is the subtler cousin. Model capacity is finite, and providers apply rate limits per user and per organization. A heavy automated workflow, or a burst of requests from a shared account, can hit those limits while a single interactive prompt sails through. The symptom is intermittent failure under load that resolves when the burst ends.
A counterintuitive detail: a perfectly healthy Copilot can appear broken because the underlying data is stale. Grounded answers depend on an index that refreshes on a schedule measured in hours, not seconds. Ask about a document edited ten minutes ago, and Copilot may correctly report it cannot find it. The service worked, the index did not.
Misconceptions that send people down the wrong path
The most common misconception is that reinstalling fixes everything. It fixes client-state problems and nothing else. If the cause is a license gap or a proxy, a reinstall wastes time and changes nothing.
A second is that a working sign-in means a working Copilot. Identity and entitlement are separate. You can authenticate perfectly and still lack the license that unlocks the feature.
A third is that Copilot "learned" wrong or "got dumber." Model behavior can shift with updates, but the sudden total failure users report is almost always infrastructural, not a change in model quality. Confusing a broken pipe with a bad answer misdirects the whole investigation.
A professional caveat worth internalizing: error messages are frequently generic by design. Providers avoid leaking policy details to unlicensed or unauthorized users, so "something went wrong" can mean "you are not entitled." Read the message as a category, not a diagnosis.
Practical actions with concrete thresholds
Work from scope outward. Each step below has a decision threshold that tells you whether to continue or stop.
Confirm scope within 5 minutes. Ask one colleague on the same license to try the same prompt. If they succeed, the fault is local; if they fail identically, suspect the service or tenant policy. Check the provider status page before anything else. A posted incident ends the investigation; if none is listed and failures persist past 15 minutes, continue. Verify license assignment in the admin center. An unassigned or recently revoked license explains silent policy blocks better than any client fix. Clear client state. Sign out and back in, then reinstall the extension or reset the browser profile. If failures stop, you found a client-state cause. Test on a different network. A mobile hotspot bypasses corporate proxy inspection. If Copilot works there, your proxy or firewall configuration is the cause. Escalate with evidence after 30 minutes of unresolved failure. Include timestamps, the exact error text, affected users, and the network path tested.
Two thresholds deserve explicit reconciliation. The 5-minute scope check and the 15-minute status check measure different things: one confirms whether others are affected, the other confirms whether the provider knows. Do not skip the first because the second looks clean. A tenant policy change affects your whole organization without ever appearing on a public status page.
Red-flag warnings:
Never disable TLS inspection organization-wide to "fix" Copilot; scope the exception to the documented Copilot endpoints instead. Do not share a single account to work around a license gap; it violates most enterprise agreements and corrupts usage telemetry. Treat repeated authentication prompts as a security signal, not an annoyance; a revoked session may indicate a compromised credential. Do not paste sensitive data into a consumer Copilot when the enterprise version is failing; the data-handling terms differ.
Comparison: which Copilot failure points where
| Symptom | Most likely layer | First test | Typical fix |
|---|---|---|---|
| Button missing entirely | License or client build | Check admin assignment | Assign license, update client |
| Button present, requests fail | Policy or authentication | Re-sign-in, check tenant settings | Refresh token, adjust policy |
| Works for others, not you | Local client state | Fresh browser profile | Reinstall or reset profile |
| Fails on office network only | Proxy or firewall | Mobile hotspot test | Allowlist Copilot endpoints |
| Intermittent under heavy use | Throttling or capacity | Reduce request rate | Spread load, request quota |
| Answers miss recent edits | Stale grounding index | Check index refresh time | Wait for reindex cycle |
This table is a starting heuristic. Overlapping symptoms are common, and a single failure can span two layers. Use it to order your tests, not to close the case.
What Copilot failures cannot tell you
No client-side troubleshooting can distinguish a content-filter rejection from a capacity throttle with certainty, because both surface as generic errors. That limit is real and worth stating plainly. When the error text is uninformative and the status page is clean, only the provider's support channel or admin telemetry can resolve the ambiguity.
The mechanisms here are stable across products and years, but specific endpoints, license names, token lifetimes, and refresh schedules change. Consult current vendor documentation for exact hostnames and settings rather than relying on figures from older guides. The diagnostic logic survives those changes; the constants do not.
For most users, the honest answer to "why isn't my Copilot working" is a broken link in a chain, not a broken product. Find which link by testing scope first, then client, then network, then service. That order resolves the majority of cases without a support ticket.
For workplace deployments involving regulated data, security policy, or contractual obligations, treat this article as general educational information rather than professional advice. It is not a security assessment or a compliance opinion, and it promises no specific outcome. Consult your organization's IT security and compliance professionals before changing network inspection, licensing, or data-handling settings.