Excel is switching off the =COPILOT() function on 14 September

What exactly is being switched off on 14 September 2026?

The worksheet function, and only the worksheet function. Microsoft’s own support page for the COPILOT function now opens with the line that starting 14 September 2026 the COPILOT function is no longer available in Microsoft Excel. Copilot in Excel as a product carries on. The thing that stops working is the version of it you could type into a cell.

Some background first, because plenty of people have read about this function without ever seeing one. The syntax was =COPILOT(prompt_part1, [context1], [prompt_part2], [context2], ...), which in plain terms means you wrote your instruction as text, handed it a range of cells to look at, and Excel put the model’s answer into the grid. It was a prompt with a cell reference stapled to it.

One detail from that page matters more than all the rest, and it comes straight back in the next section. Microsoft documents that the function can return multiple results as a dynamic array that spills across the grid. A spilled range means one formula, written in one cell, filling a whole block of cells around it. The cells in that block are not formulas of their own. They are the output of the single cell at the top.

The function also never reached general availability. It ran in the Frontier program and the Microsoft 365 Insider program and was pulled before it ever shipped to everybody. That sounds like it makes this a small story, and it does the opposite. The people in those programs are the people who build things, so the formula is sitting in exactly the workbooks somebody now depends on.

What happens to a workbook that already has =COPILOT() in it?

At first nothing visible happens, because Microsoft’s page now says results that were already calculated remain in the workbook as cached values. The change comes when the cell recalculates, for example when somebody edits one of the cells it reads. The function then returns a #NAME? error, because Excel no longer recognises it, and everything it produced goes with it. That last step is what people underestimate, and the reason is the spilling behaviour from Microsoft’s own page.

Picture the sheet almost everybody built with this. Column C holds three hundred rows of raw support ticket text. In D2 you wrote one =COPILOT() that reads C2:C301 and categorises each row, and it spilled three hundred categories down column D. Beside it you put a COUNTIFS block that counts each category, and on top of that a chart, and the chart is the thing somebody screenshots for the Monday call.

There is one formula in that entire structure. Until it recalculates, the three hundred cells underneath it keep showing their cached categories. Once it does, D2 shows #NAME? and the three hundred cells are not stale, they are empty, because they were never independent cells in the first place. The COUNTIFS block then counts nothing and the chart draws nothing, and not one of those three things was edited by anybody.

When I first wrote this I called the failure loud, and once it arrives it is. An empty column and a blank chart get noticed in the first ten seconds. The cached values are what change that, because a file still showing its old answers looks exactly like a file that is fine, so it can sit on a shared drive for weeks and then break the moment somebody edits a ticket in column C. That puts it much closer than I first thought to the silent errors that reach the final report and quietly move a number nobody re-checks.

What makes it worth an hour of your time rather than five minutes is the blast radius. You are not hunting for cells that contain the word COPILOT, you are hunting for every range those cells fed, and the second list is always longer than the first.

How do you find every =COPILOT() formula before the date?

With one search and one habit. The search has a setting in it that most people get wrong, and the habit is checking what reads the output before you touch the output itself.

1. 01
   Search the formulas, not the values

   Ctrl+F, then click Options. Type COPILOT, set Look in to Formulas, and set Within to Workbook rather than Sheet. Searching values finds nothing useful, because the cell displays the model’s answer and not the formula that produced it.
2. 02
   Click each hit and read the formula bar

   A spilled range shows the live formula only in its top-left cell, and every other cell in the block shows that same formula greyed out. What you are saving is the whole block, so select the block rather than the one cell you happened to land on.
3. 03
   Trace what depends on it before you change anything

   With the top-left cell selected, use Formulas then Trace Dependents. That draws arrows to everything reading the spilled range, which is the list you actually have to protect. Do it first, because once the block is values the arrows tell you much less.
4. 04
   Freeze the output you want to keep

   Select the block, Ctrl+C, then Ctrl+Shift+V for Paste Values. Microsoft suggested exactly this on the function’s own page for anyone who did not want results to recalculate, so it was the recommended pattern long before any retirement notice existed.
5. 05
   Re-home the columns that have to stay live

   Anything that has to answer again next month is not a paste-values job, it is a rebuild, and the next section is the map for it. Leave these until last, once the file is already safe.

One more thing worth doing while the file is open. If the categories in that column came out of a model, they will contain near-duplicates from the moment the phrasing drifted, so you may have Billing, billing and Billing issue all sitting inside what everyone treats as one category. Freezing the values is still the right move, and it freezes that too, which is a cleaning job arriving through the front door.

Where does each job you used it for actually go now?

People used =COPILOT() for four things, and separating them is worth the effort, because the four do not move to the same place and only one of them genuinely loses something in the move.

The first job was tagging a column: reading each row and assigning it a category, a priority or a sentiment. Most of the time the set of categories is already known and was simply never written down, and once you do write it down the job is a lookup table plus XLOOKUP, or a Power Query merge when the matching is fuzzier. That is faster, it is free, and it gives the same answer every time.

The second job was extraction: pulling a city out of an address, an invoice number out of a description, a product code out of a subject line. That is a rule, even when it takes a while to state, and rules belong in TEXTBEFORE, TEXTAFTER and TEXTSPLIT, or in Power Query when the input is messy enough to need steps. Choosing between those two is the same decision I worked through in Power Query or Python first.

The third job is the real one. Summarising free text, reading intent out of a complaint, turning thirty comments into one honest line. No formula does that, so this is the job that moves to the Copilot side pane or to a script, and it is the job where you feel the loss.

The fourth job was calculating or deciding something numeric, and it moves nowhere, because it should never have been there. Microsoft’s page for the function says plainly that it cannot reliably perform numerical calculations, and puts tasks with legal or compliance implications in the same sentence. If a =COPILOT() in your file was working out a figure somebody acted on, this retirement is doing you a favour.

Read the last column downward and the shape of the week appears. Three of the four jobs come out of this better than they went in, and one of them, the summarising, comes out worse, and there is no way to dress that up.

Why was a formula in a cell always the fragile place for this?

Because a spreadsheet makes one promise, and this function could not make it. The promise is that the same inputs give the same answer, today, in March, on your laptop and on the auditor’s. Everything anyone trusts a workbook for is built on that single line.

Microsoft broke that promise in writing, on the function’s own documentation, long before any retirement notice existed. The page states that the model will evolve and improve in future, and that formula results may change over time even with the same arguments. Read that as a normal person and it is a reasonable product note about a tool getting better. Read it as somebody who has to sign off a number and it says the cell was never really a formula.

Three more documented properties point the same way. It needed an active internet connection, so a workbook that answered on the train did not answer on the plane. It was rate limited to up to 100 COPILOT functions every ten minutes, so a long fill-down came back in pieces rather than failing cleanly. And it would not calculate at all in a workbook labelled Confidential or Highly Confidential, which is precisely the label that finance and HR files carry.

None of those is a scandal. Every one of them is completely normal for a tool and completely wrong for a formula, and that mismatch is the actual story here. This retirement is not Microsoft going cold on AI in Excel. It is Microsoft taking away the one place where AI output was dressed up as a calculation.

The useful part is that this was not one vendor’s mistake, so it is not one vendor’s lesson either. Google shipped its own version of the same idea and documented the same species of limits, which I went through in the AI function in Google Sheets is a button, not a formula: static output that never refreshes itself, a cap of 350 cells in one go, and no nesting inside another function. Two companies, two independent teams, and both of them ended up telling you the same thing about where a model belongs in a spreadsheet.

Is the Copilot side pane actually a replacement?

For the capabilities, mostly yes. For the shape of the work, no. It is worth being precise about which is which, rather than accepting or dismissing the swap whole.

Microsoft’s position is that customers can carry on using Copilot in Excel through the side pane, which provides many of the same capabilities, including summarising text, classifying data, generating content and retrieving information from the web. Taken as a list of things it can do, that is accurate. Every one of those jobs is still available to you next week.

What changes is where the work lives. A formula sits in the file, recalculates when its inputs change, spills into a range, and is visible to anybody who opens the workbook and clicks the cell. The side pane sits in your session. What it produces arrives in the sheet as values, and the prompt that produced it lives in your chat history rather than in the file, so the next person to open the workbook sees an answer and no trace of the question.

For summarising that is mostly fine, because that job never wanted to be live in the first place. For tagging it means the work becomes an explicit batch, done on a date, by a person, which is honestly what it should always have been. The thing you genuinely lose is the fill-down. Dragging a prompt down a column was the good idea inside this function, and nothing in the side pane gives it back.

If you want the wider picture of which AI tools earn a slot in an analyst’s week and which do not, that is the stack I actually use, and the tools I build around it come with the membership rather than being sold one at a time. The habit underneath both is the one from asking AI for Excel formulas: let the model write the thing you can check, and keep the thing you cannot check out of the grid.