COPILOT() in Excel: AI-powered formulas rethink spreadsheets

Microsoft is rolling a generative AI function directly into Excel’s calculation engine — a native formula called COPILOT() that lets users pass natural‑language prompts and optional grid ranges to a cloud AI model and receive live, recalculating outputs inside cells, a capability that closely mirrors Google Sheets’ AI() function introduced months earlier. (neowin.net) (techcommunity.microsoft.com)

Background​

Spreadsheets have long been the lingua franca of business operations, analytics, and ad‑hoc automation. Recent advances in large language models (LLMs) and productized AI assistants have pushed vendors to embed generative AI directly into productivity tools. In June 2025, Google added an AI() function to Google Sheets that allows users to write a natural‑language prompt and optionally reference spreadsheet ranges for summarization, categorization, sentiment analysis, or text generation. That feature was announced via Google Workspace updates and accompanied by examples such as:

• =AI("Write a formal ad copy for the product. Cater copy to the objective and target audience", A2:C2)
• =AI("Categorize the customer inquiry as a compliment, exchange request, or return request.", C2)

Google’s rollout began June 25, 2025 and targeted Workspace tiers and Gemini subscribers. (workspaceupdates.googleblog.com)
Microsoft’s response is the COPILOT() function, introduced to Microsoft 365 Beta Channel Insiders with Copilot licensing. Microsoft positions COPILOT() as a first‑class Excel function: you type the function into a cell, provide a prompt and optional context ranges, and Excel returns AI‑generated results that behave like other dynamic array functions — they spill, they update when dependent cells change, and they can be nested inside Excel constructs such as IF, SWITCH, and LAMBDA. The announcement and guidance were published on Microsoft’s Insider blog on August 18, 2025. (techcommunity.microsoft.com)

---

What COPILOT() does — the mechanics​

Syntax and basic usage​

• Basic form: =COPILOT(prompt_part1, [context1], [prompt_part2], [context2], ...)
• Example: =COPILOT("Classify this feedback", D418)

The function accepts one or more prompt parts (plain text) and zero or more context references (single cells or ranges). When invoked, COPILOT() sends the prompt and referenced data to Microsoft’s Copilot service, which returns a result that Excel inserts into the grid. Because COPILOT() is integrated into Excel’s calculation engine, outputs recalculate automatically when the referenced data changes — you don’t need to run a refresh or re‑invoke a separate add‑in. (techcommunity.microsoft.com)

How it fits into formulas and arrays​

COPILOT() is designed to interoperate with Excel’s existing formula ecosystem. Microsoft documents that COPILOT() can:

• Spill multi‑row/multi‑column outputs into adjacent cells (like WRAPROWS).
• Be nested inside logic and array constructs: IF(COPILOT(...)=..., ...), SWITCH(COPILOT(...), ...), and fed into LAMBDA functions.
• Accept the output of other functions as part of its prompt, allowing programmatic composition.

This makes COPILOT() behave as a first‑class function rather than a siloed “AI tool” outside the formula layer. That architectural choice affects automation, auditability, and reuse: AI outputs become part of calculation chains and dependency graphs. (techcommunity.microsoft.com)

Quotas, grounding, and limitations (initial rollout)​

At launch Microsoft has set explicit usage limits to manage scale:

• 100 calls every 10 minutes.
• Up to 300 calls per hour.

Microsoft recommends batching larger ranges into a single call (pass an array) to conserve quotas; each cell filled individually counts as a separate call. COPILOT() currently does not access live web data or enterprise content automatically — you must import internal data into the workbook and reference it. Microsoft has signposted plans to expand quotas, add live web/internal data integrations, and improve large‑array handling. (techcommunity.microsoft.com)

---

How COPILOT() compares with Google Sheets’ AI()​

Feature parity at a glance​

Both functions share common ground: they let users call LLM‑based assistants directly from cells with a plain‑language prompt and optional range references. Use cases include sentiment classification, summarization, categorization, list/table generation, and brainstorming.
Key differences at introduction:

• Google’s AI() function was announced June 25, 2025 and initially supported text generation, summarization, categorization, and sentiment analysis with a 200‑cell processing limit in some flows and a manual refresh step when inputs changed. Google exposes AI() via the “Ask Gemini” side panel and also in‑cell =AI() usage. (workspaceupdates.googleblog.com)
• Microsoft’s COPILOT() targets tight integration with Excel’s calculation engine so that results update automatically as source data changes — an important UX advantage in heavily calculated workbooks. Microsoft also emphasizes formula interoperability (IF, LAMBDA, SWITCH, etc.) and ability to spill structured outputs. COPILOT() was announced for Insider Beta Channel users with explicit build numbers and licensing requirements. (techcommunity.microsoft.com) (neowin.net)

Timing and market messaging​

Google launched AI() publicly in June and emphasized Gemini integration across Workspace. Microsoft’s COPILOT() announcement in mid‑August is positioned as a catch‑up and refinement: it adopts the in‑cell prompt approach but stresses “first‑class” formula integration and automatic recalculation — messaging tailored to Excel power users and enterprises who rely on deterministic recalculation and formula composability. Observers note Microsoft bringing Copilot deeper into Excel in multiple forms: formula generation, inline formula explanations, and now COPILOT() as a formula. (workspaceupdates.googleblog.com) (techcommunity.microsoft.com)

---

Practical use cases: what this enables today​

• Sentiment analysis and tagging: classify open‑text responses, customer reviews, or support tickets with a single formula.
• Summaries and executive notes: create concise narrative summaries from long text ranges for dashboards.
• Rapid dataset enrichment: produce SEO keyword lists or outreach messaging tailored to each row’s context.
• Formula generation and explanation: generate formulas from plain‑language requests and explain opaque formulas inline.
• Test and mock data creation: quickly create lists/tables for testing scenarios or prototyping models.

Real‑world examples from Microsoft’s demos include classifying coffee machine reviews and extracting structured tables from text ranges. Because outputs are formulas and thus auditable in Excel’s dependency model, teams can fold AI results into existing automation and reporting pipelines. (techcommunity.microsoft.com)

---

Security, privacy, and compliance considerations​

What Microsoft says​

Microsoft states that content passed through the COPILOT() function is not used to train their foundation models; enterprise tenant protections and training opt‑outs are part of their product governance. However, the specifics of data residency, telemetry, and processing location depend on tenant type, licensing, and regional regulations. Admin controls and sensitivity label gating can block AI features for protected content. (techcommunity.microsoft.com)

Practical cautions for IT​

• Data residency: organizations with strict residency requirements must verify where AI processing occurs and whether the tenant’s compliance level supports Copilot features.
• Sensitivity labels: labeled/confidential workbooks may block Copilot actions; admins should test policies in a staging environment.
• Audit trails: because COPILOT() produces outputs that become part of calculation chains, version control and change auditing become even more important; maintain copies and use workbook protection to avoid accidental propagation of AI decisions.
• Model behaviour: LLMs can hallucinate; treat AI outputs as assistive, not authoritative — always validate critical computations and decisions.

---

Licensing and rollout: who gets it and when​

• COPILOT() is initially available to Microsoft 365 Beta Channel Insiders who hold a Microsoft 365 Copilot license.
• Minimum builds published for initial desktop rollout: Windows Version 2509 (Build 19212.20000) and Mac Version 16.101 (Build 25081334). Web availability is planned via the Frontier program and broader rollouts will follow. Microsoft also reiterates that functionality and quotas will evolve. (techcommunity.microsoft.com)

IT administrators and procurement teams should plan pilot programs, confirm licensing eligibility, and ensure Insider builds are used only in controlled test environments to evaluate behaviour and governance implications.

---

Critical analysis — strengths, risks, and operational impact​

Strengths​

• Seamless integration: Making AI a native Excel function that participates in the calculation graph reduces friction substantially for teams that already depend on formula-driven updates. This is a meaningful UX improvement over side‑pane or static add‑in approaches. (techcommunity.microsoft.com)
• Composability: COPILOT()’s ability to interoperate with IF, LAMBDA, SWITCH, and array functions means AI results can be embedded in deterministic workflows, enabling automation without rearchitecting spreadsheets.
• Familiar interface: Power users keep using the grid and formulas they trust — prompts are just another input type, which lowers adoption barriers for business users.
• Administrative controls: Microsoft’s tenant and sensitivity label controls give enterprises levers to restrict or permit Copilot features in regulated environments.

Risks and limits​

• Hallucination and correctness: LLMs occasionally produce plausible but incorrect outputs. When these outputs become part of downstream calculations, they can silently propagate errors. Teams must validate AI outputs with deterministic checks.
• Operational cost and quotas: The initial usage quotas (100 calls/10 minutes; 300 calls/hour) could create throttling or unexpected service behavior in high‑volume scenarios. Enterprises must design around quotas (batching, single-call arrays) and forecast Azure/Copilot consumption costs. (techcommunity.microsoft.com)
• Data residency & regulation: Countries and industries with strict data handling rules will need explicit assurances about where and how workbook data is processed. Even with model‑training opt‑outs, telemetry and metadata flows can raise compliance questions.
• Overreliance and skill erosion: There is a behavioral risk that teams stop defending or testing formulas because Copilot “explained” them — but an AI explanation is not a formal audit. Critical financial, legal, or regulatory logic still requires human oversight and reproducible test ranges.

Architectural consequences​

Embedding generative AI into the formula engine shifts the spreadsheet from a purely deterministic computation layer to a hybrid system with probabilistic outputs. This makes traceability and reproducibility more complex:

• Repro steps must record prompt text and context references used for each COPILOT() call.
• Tests must include known‑input/expected‑output ranges to guard against drift as AI models change.
• Change control should capture AI‑generated formulas and their provenance to maintain auditability.

Enterprises should update change management and QA processes to treat AI functions as part of the development lifecycle.

---

Recommendations for admins, power users, and developers​

For IT administrators​

• Pilot COPILOT() in a controlled tenant with test data and explicit governance.
• Review sensitivity label behavior and tenant settings for Copilot to prevent leakage.
• Validate the processing location and contractual guarantees for data residency and compliance.
• Define cost monitoring for Copilot usage and set alerts for quota/consumption spikes. (techcommunity.microsoft.com)

For spreadsheet owners and power users​

• Treat COPILOT() outputs as assistive — always validate with deterministic tests and sample inputs.
• Embed prompt text in the workbook (adjacent cells or hidden metadata) so outputs are reproducible.
• Use single‑call arrays where possible to reduce quota consumption.
• Keep manual fallback formulas and document the reasoning behind AI‑driven decisions.

For developers and automation engineers​

• When possible, wrap COPILOT() outputs in sanity checks (e.g., validate returned categories against a fixed taxonomy).
• Use LAMBDA wrappers to centralize prompt composition and pre/post‑processing so changes propagate consistently.
• Version prompts and model usage patterns in source control external to the workbook for long‑term traceability.

---

Where this fits in the broader productivity AI arms race​

Google’s early introduction of AI() in Sheets demonstrated that in‑cell LLM calls are feasible and valuable. Microsoft’s COPILOT() refines that concept for Excel’s ecosystem by emphasizing calculation engine integration, formula composition, and enterprise controls — attributes that matter more in complex, mission‑critical spreadsheet environments.
Both companies are converging toward a world where spreadsheets are not just numeric grids but conversational, intelligent surfaces. That evolution will accelerate user productivity for routine tasks but will also require new governance disciplines: prompt versioning, model‑aware QA, and stronger auditability practices.

---

Final assessment​

Microsoft’s COPILOT() represents a pragmatic, well‑targeted advance: it brings generative AI into Excel in a way that respects the application’s core strengths — formulas, recalculation, and composability. By making AI outputs behave like standard functions, Microsoft reduces friction for adoption across analysts, finance teams, and large enterprises. However, the novelty introduces nontrivial governance and operational challenges: hallucination risk, quota and cost management, data residency concerns, and the need to treat AI outputs as first‑class artifacts requiring testing and version control.
Organizations should welcome COPILOT() as a productivity amplifier but adopt it deliberately: start small, pilot with non‑sensitive data, codify validation procedures, and update audit practices. With those guardrails, COPILOT() — and its cousins across the spreadsheet ecosystem — can deliver meaningful time savings without compromising the integrity of business decisions.

---

Microsoft’s COPILOT() and Google’s AI() are not merely feature releases; they mark a structural shift in how spreadsheets are authored and consumed. For Excel power users and administrators, the opportunity is to harness these tools while preserving the discipline that made spreadsheets reliable in the first place: reproducibility, testing, and careful audit trails. (techcommunity.microsoft.com, workspaceupdates.googleblog.com, neowin.net)

---

Source: Neowin Microsoft finally testing an Excel feature that was introduced in Google Sheets months ago