Meet the Contributors: The LibreOffice Features That Replaced Our Need for Copilot

Why some teams walked away from Copilot — and why LibreOffice kept them productive

Hook: If your organisation is wrestling with the trade-offs of cloud-first AI assistants — privacy risks, unpredictable network dependency, and licenses that don’t fit your governance — you’re not alone. In 2025–26 many IT teams and developers started to ask: can an offline, open-source office suite replace the Copilot-driven workflow without losing productivity? We spoke with contributors who deliberately built LibreOffice features to answer that question. Their work prioritised privacy, offline capability, and UX improvements that replicate the productivity wins people expect from AI — but on their own terms.

Quick takeaways (for the busy reader)

• LibreOffice contributors focused on augmenting existing capabilities (AutoText, templates, macros, document metadata, and local grammar tools) rather than cloning Copilot.
• Privacy-first integrations (local LanguageTool, on-device inference hooks, and self-hosted collaboration) let teams keep sensitive documents in-house.
• Practical migration path: pair LibreOffice with self-hosted services (Nextcloud + Collabora/LibreOffice Online) and local LLM endpoints for optional, auditable assistance.
• Actionable admin steps and a sample PyUNO snippet to call a local assistant appear later in this article.

The problem contributors were asked to solve

When organisations migrated away from Microsoft 365 Copilot in late 2024–2025, they reported three core pain points:

1. Loss of in-application assistance that felt context-aware (summaries, rewrite suggestions, draft generation).
2. Concerns about sending proprietary content to third-party AI services.
3. End-user friction when switching between cloud-native workflows and local tools.

LibreOffice’s volunteer and corporate contributors set out to mitigate these gaps without compromising the suite’s open, offline-first nature.

Meet the contributors (community spotlight)

Anna — Privacy & Extensions Lead

“We didn’t want to make an on‑call AI. We wanted to make features that give the same velocity — predictable, auditable, and private.”

Anna led the effort to standardise extension hooks for local services. Her team built an extension registry specification that clearly separates local endpoints from remote services, with explicit user consent and per-document policy enforcement.

Jon — UX Lead and Contributor

“A big part of ‘Copilot-like’ value is discoverability. We redesigned contextual menus and AutoText so users can reach advanced actions in two clicks.”

Jon focused on reducing cognitive load: Quick Actions, an improved NotebookBar, and contextual suggestions for Writer and Calc that run without sending data off-device.

Marcus — Core & API Integrations

“We built the plumbing so admins can plug in anything from a local LanguageTool instance to an on‑prem LLM — and control what gets logged.”

Marcus implemented API endpoints and sample integrations that use the UNO runtime to let external local services augment documents while leaving ODF files unchanged and fully auditable.

What they built — feature highlights that replaced Copilot workflows

1. Local, privacy-first assistants via an “Assistant Extension” model

Instead of bundling a single assistant, contributors created an assistant extension model. Key points:

• Extensions register a capability (summarise, rewrite, translate, cite) and expose a local REST endpoint.
• LibreOffice calls the endpoint only after explicit user action or policy-based triggers (no silent telemetry).
• Administrators can enforce allowlists/denylists and set logging policies.

Result: teams can run LanguageTool on-premises for grammar checks or attach an internal LLM like a secure Llama-derived service to produce rewrites — all without sending docs to external clouds.

2. Expanded AutoText + Smart Templates

AutoText—long used for boilerplate—got an upgrade. Contributors added:

• Context-aware AutoText that populates fields based on document metadata (author, department, project code).
• Conditional templates that can inject clauses or warnings depending on sensitivity tags.
• Shared AutoText libraries distributed via enterprise templates or Nextcloud folders.

These small, local automations replace many of the repetitive tasks Copilot users rely on — with no network dependency.

3. Offline grammar and style: Local LanguageTool and Hunspell integration

Grammar, tone, and style suggestions are central to Copilot’s perceived value. LibreOffice contributors made it easy to run these tools locally:

• Ship-ready integration with LanguageTool Server (self-hosted) via the assistant extension model.
• Improved Hunspell dictionaries and faster suggestion UI for typographical fixes.
• Policy options let compliance teams turn off “rewrite” suggestions while allowing corrections.

4. Document intelligence without cloud telemetry: Metadata-driven actions

Instead of opaque AI heuristics, contributors leaned into explicit metadata. Examples:

• “Document Classification” tags (manual or automated by internal tools) that trigger different template branches.
• Preview actions that show what a rewrite would do without applying it — keeping users in control.

5. Collaboration that preserves privacy: self-hosted Collabora/LibreOffice Online + Nextcloud

For teams that need concurrent editing, contributors emphasise self-hosting Collabora Online or Nextcloud integration. The recommended stack in 2026:

• Nextcloud for file sync and access control
• Collabora Online for browser-based editing (runs in your data center)
• Optional Assistant Extension endpoints reachable only from your network

This gives many of the collaboration advantages of Copilot (contextual edits, shared drafts) while keeping data on-premise.

Practical walkthrough: Attach a local assistant (LanguageTool or on‑prem LLM)

Below is a concise, actionable pattern used by contributors to connect LibreOffice to a local assistant. The pattern uses the UNO API from Python and calls a local HTTP endpoint. This example assumes you run a local assistant at http://127.0.0.1:8080/assist.

from __future__ import annotations
import uno
import requests

# Connect to a running LibreOffice instance (pyuno)
localContext = uno.getComponentContext()
resolver = localContext.ServiceManager.createInstanceWithContext(
    "com.sun.star.bridge.UnoUrlResolver", localContext)
ctx = resolver.resolve("uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext")
smgr = ctx.ServiceManager
desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop", ctx)
model = desktop.getCurrentComponent()

# Extract selected text in Writer
selection = model.getCurrentController().getSelection()
if selection.supportsService("com.sun.star.text.TextRange"):
    text = selection.getString()
else:
    text = ""

# Call the local assistant
resp = requests.post("http://127.0.0.1:8080/assist", json={"action": "rewrite", "text": text})
if resp.status_code == 200:
    new_text = resp.json().get("result", "")
    # Replace selection with assistant result
    if new_text:
        selection.setString(new_text)

Notes from contributors:

• Run the LibreOffice instance with --accept="socket,host=localhost,port=2002;urp;" for UNO connectivity.
• Enforce mutual TLS between LibreOffice clients and the assistant endpoint for additional safety.
• Log only request hashes and action meta (not raw document content) when compliance requires minimal telemetry.

Admin checklist: Deploying a Copilot-free productivity stack

Contributors recommend this pragmatic checklist for teams moving away from Copilot:

1. Inventory where Copilot sends content today. Tag document classes with sensitivity levels.
2. Deploy Nextcloud (optional): centralised file control and access policies.
3. Deploy Collabora Online if concurrent editing is required — run it in a private network or Kubernetes namespace.
4. Run LanguageTool Server or an on-prem LLM endpoint behind your VPN, and register it as an assistant extension.
5. Enable auditing: keep a small, secure log of assistant calls with request IDs (not full text) for compliance.
6. Train users: show how AutoText, Quick Actions, and templates replace common Copilot tasks.

UX lessons from contributors — what actually keeps users productive

Jon summed it up: productivity is as much about discoverability as capability. The contributors emphasised:

• Two-click flows: Make advanced actions accessible from right-click or a single toolbar button.
• Preview-first: Always show a diff/preview so users can accept or reject changes.
• Conservative defaults: Don’t apply rewrites without consent; provide a history for rollbacks.

Security & governance: what contributors baked in

Privacy and governance were design-first constraints. Implementations reflect three principles:

1. Least privilege: Assistant endpoints run with minimal access; admins can scope endpoints to specific subnetworks or namespaces.
2. Auditability: Requests are tagged and hashed; administrators can reconcile actions with document IDs for incident response.
3. Policy enforcement: Document templates and AutoText can embed policy warnings for classified content.

Real outcomes — early adopter stories

Several small governments and engineering firms that migrated in 2025 reported:

• Lower licensing costs and eliminated Copilot data egress concerns.
• Stable productivity metrics after a two-week ramp-up where AutoText and templates absorbed many repetitive tasks.
• Fewer security incidents tied to external AI services — although operational overhead increased for self-hosting.

Contributors say this trade-off is expected: you get control and privacy at the cost of additional infrastructure work — but for many organisations that’s an acceptable, even preferable, exchange.

Advanced strategies: hybrid models and future predictions (2026+)

Contributors foresee several trends through 2026:

• On-device inference will become more feasible for standard business tasks as quantised models and specialised inference libraries mature.
• Policy-first assistant registries (like the Assistant Extension model) will standardise how desktop apps integrate local and remote helpers.
• Interoperability between self-hosted LLM endpoints and ODF metadata will enable auditable writing assistants that are acceptable to regulators.

Practical hybrid approach: run a private LLM for non-sensitive document generation, but route highly sensitive documents to purely deterministic tools (AutoText, macros, and LanguageTool).

How to join the effort — contributor resources

If you want to contribute or test these patterns, contributors recommend these starting points:

• Get the latest LibreOffice Nightly or community builds; many assistant hooks landed in 2025–26 development branches.
• Test the Assistant Extension API in a dev environment and run a local LanguageTool server for quick wins.
• Share feedback and sample integrations on project mailing lists and the extensions repository so others can audit and reuse them.

Actionable next steps (for IT leads and developers)

1. Run a one-week pilot: pick a team, deploy LibreOffice + local LanguageTool, and enable AutoText templates.
2. Measure qualitative productivity: time-to-first-draft, number of manual edits, and user satisfaction.
3. Iterate: enable assistant endpoints only after documenting audit and encryption approaches.

Final thoughts from the contributors

“Our goal was not to beat Copilot at its own game. It was to give teams the same day-to-day velocity without surrendering control of their data,” Anna told us. “Open source wins when it respects user agency.”

Jon added: “Users don’t care where suggestions come from — they care that they’re fast, accurate, and reversible.”

Conclusion — why this matters in 2026

In 2026, the debate over AI assistants in productivity applications has matured from “can it write?” to “who owns the output, and who saw the input?” LibreOffice contributors offered a pragmatic, community-led alternative: provide the productivity primitives people expect — suggestions, rewrites, templates, collaborative editing — while keeping control over data and governance. For organisations prioritising privacy, auditability, and offline capability, LibreOffice plus a modest self-hosted stack can replace Copilot-driven workflows without a productivity penalty.

Call to action

Try it yourself: install the latest community build of LibreOffice, deploy a local LanguageTool or small LLM endpoint in a test network, and follow the integration pattern above. If you build a useful assistant extension, publish it to the LibreOffice extensions repository and share your deployment playbook on the project mailing lists — contributors and admins are actively sharing improvements in 2026. Want help planning a migration or pilot? Reach out to your community contributors or post in the LibreOffice channels with your architecture and constraints — the community will help.

Related Reading

• Incident Response Template for Document Compromise and Cloud Outages
• Edge Auditability & Decision Planes: An Operational Playbook for Cloud Teams in 2026
• Edge-Assisted Live Collaboration: Predictive Micro‑Hubs & Real‑Time Editing
• The Evolution of Site Reliability in 2026: SRE Beyond Uptime
• Cheat Sheet: 10 Prompts to Use When Asking LLMs
• Cashtags for Creators: How to Leverage Financial Tags to Build Monetizable Content
• Review: Compact Resilience Kits for High‑Stress Days — Tech, Light and Nutrition (2026 Hands‑On)
• How Colored Lights Impact Your Skincare Routine and Makeup Application
• Marketplace Deals Roundup: Best Car Owner Discounts This Week (Robot Vacs, Speakers, Smart Lamps)
• Display Like a Pro: Lighting Tricks to Showcase Your Zelda Lego Set