Handy Tools

How to let Claude Code edit Word, Excel and PowerPoint files on your Mac

Claude Code cannot read an Excel file on its own: its Read tool refuses a file whose extension it treats as binary, such as .xlsx. This guide goes through each way to let Claude Code edit Word, Excel and PowerPoint files on a Mac, from what it manages alone to connecting a document app over MCP or plain HTTP, and what each way cannot do.

What Claude Code does with Office files by itself

Claude Code’s Read tool refuses a file whose extension it treats as binary, such as .xlsx, .parquet, .heic or .zip. When that happens, the error suggests a skill for that file type if one is available, or else a shell command or script that reads the format.

The Claude Code docs page checked names .xlsx among the refused extensions; it does not name .docx or .pptx. To edit these files with Claude Code you connect it to something that can open them, which is what the rest of this guide does.

Connect Quill, Tally or Deck to Claude Code over MCP

Quill is a word processor for .docx files, Tally is a spreadsheet for .xlsx, and Deck is a presentations app for .pptx. While one of them is running it serves its actions over MCP on a loopback port, and because a ribbon button, a menu item, a keyboard shortcut and an agent’s call all go through the same action registry, every command the app can perform is open to Claude Code.

  1. Open the app (Quill, Tally or Deck). Its agent server runs only while the app is running.
  2. Choose Connect an Agent… from the app’s own menu (Quill, Tally or Deck) or from its Help menu. The Connect an Agent window shows the line that connects Claude Code, with the token filled in.
  3. Run that line in a terminal. For Quill it is: claude mcp add --transport http quill http://127.0.0.1:47811/mcp --header "Authorization: Bearer <token>"
  4. For Tally the same line uses the name tally and port 47812; for Deck, the name deck and port 47813.
  5. In Claude Code, run /mcp to check the server’s status, then ask Claude to work on a document.

Local scope is the default: a local-scoped server loads only in the project where you added it and stays private to you. Add --scope user to make the server available across all projects, or --scope project to share it via .mcp.json. The claude mcp add command saves the configuration without validating credentials, so run /mcp and check that the server’s row shows a checkmark. The --transport and --header flags also accept the short forms -t and -H, claude mcp list lists configured servers, and claude mcp remove <name> removes one.

The app has to be running, because the server exists only while it is open, and it listens on 127.0.0.1 only, so Claude Code has to be on the same Mac. Every request needs Authorization: Bearer <token>. The port is fixed and the token is kept between launches, so a connection Claude Code has saved keeps working.

What the agent can read back to check its work

Every part of the document has read actions that return the content and the state as JSON, enough for an agent to check its own work without a screenshot, and an action that renders a page, a sheet range or a slide to a PNG file for when it does want to look. What an agent does shows in the window as it happens and can be undone there; in Quill, one action is one step to undo, and edit_undo takes back exactly the last action.

The read actions differ by app. Quill has text_get, which returns plain text or paragraphs with style, alignment, list, table cell, page and character runs, plus outline_get, tables_get, selection_get, document_info, page_setup, review_word_count, review_spelling, find_text and styles_list, and page_render writes a page to a PNG. Tally’s cells_get returns, for a range, the values, the formulas and the displayed text of each cell, for example value 22200, formula "=B2*12", text "$22,200.00", and range_render writes a range to a PNG. Deck’s slides_get gives every run’s real font, size and colour (not "inherited"), fontScale when a placeholder’s text was shrunk to fit, and overflows: true when text runs out of its box; slides_add answers with warnings when the layout had no place for something it was given, and slides_render writes PNGs of the slides and returns the paths.

A call answers {"ok":true,"result":…} or {"ok":false,"error":{"code":…,"message":…}}, and errors say what was wrong and what to do instead. Arguments are checked before an action runs: unknown names, wrong types and missing required arguments are refused with a message that names the argument. Files are saved with documents_save, where a path does a Save As, copy: true exports, the extension picks the format, and a path ending in .pdf with copy: true exports a PDF. Big data such as images and files is passed by path, not inline; file paths are absolute, with a leading ~ expanded.

Not every action is for agents. Those whose names end in _show, _dialog or _choose, and Quill’s format_painter, show something to the person at the Mac and return at once, so an agent has no use for them. The only things outside the actions are direct mouse and keyboard manipulation, each of which has an action that gets the same result.

Without MCP: plain HTTP with curl

The same actions are served over plain HTTP, so you can drive the app from any agent or script that can post JSON, with no MCP involved. Every request needs the header Authorization: Bearer <token>, and the app writes its address and token to ~/Library/Application Support/<App>/agent.json (mode 600) when the server starts. Requests with an Origin header or a foreign Host are refused, which keeps web pages out. Deck’s Connect an Agent window shows this second line under the label "Any agent, over HTTP".

  1. Read the token from ~/Library/Application Support/<App>/agent.json.
  2. List the actions: curl -s -H "Authorization: Bearer $token" http://127.0.0.1:<port>/v1/actions
  3. Run one: curl -s -H "Authorization: Bearer $token" -X POST http://127.0.0.1:<port>/v1/actions/<id> -d '<JSON arguments>'

GET /v1 returns the app’s name, version and instructions, and GET /v1/actions lists every action with its arguments as JSON Schema. This is the same server MCP uses, so the same limits apply: it exists only while the app is open, and it listens on 127.0.0.1 only.

With Quill, Tally and Deck

Quill, Tally and Deck are the apps this guide connects. Quill is a word processor for .docx files, Tally is a spreadsheet for .xlsx, and Deck is a presentations app for .pptx. They share one foundation, the action registry, the agent server, the ribbon and the zip reader, so they look and work the way people know from Office, and everything they can do is open to an agent on the same Mac. The ribbon can only be built from action ids, so a command can’t exist in the interface without being callable.

Agents address things explicitly rather than by selection: Tally by A1 ranges with an optional sheet, Deck by slide number and stable object ids, and Quill by offset and length, paragraph number, or find text. An agent can also work on a document that isn’t in front, by passing a document id from documents_list or documents_new. Deck opens a file made in another app as an untitled copy, reports madeInAnotherApp: true in deck_get, and lists in notKept what a save would not keep.

Each app costs $19 once, in US dollars, tax included, and is free for 7 days with no card. One licence covers up to 3 of your Macs, every future update is included, and refunds are available within 30 days; there is no subscription and no account. They need macOS 14 Sonoma or later. Each app keeps only part of what an Office file can hold: Quill drops comments and tracked-change deletions, Tally does not keep charts or pivot tables, and Deck does not keep animations or charts. Once the 7-day trial has ended, saving, exporting and printing ask for a licence, and an agent that calls documents_save is told why.

Try Quill free for 7 days.

Then $19 once, for up to 3 of your Macs. No subscription and no account.

Download QuillBuy · $19About Quill

Requires macOS 14 Sonoma or later.

Sources

Checked on 13 November 2026.