Attaching Files to Chat: Documents, Images & Audio

Macha's chat handles files directly. You can drag and drop documents, images, and audio onto the chat input, and the agent reads them the way you'd hope: it extracts text from documents, looks at images with a vision model, and transcribes audio into words it can reason over. This shipped on March 1, 2026, and it turns the chat box from a text field into a place where you can hand the agent the actual artifact instead of describing it.

This post walks through how it works for each file type, what happens to the file after you send it, where the credits go, and — importantly — when you should not use a one-off chat upload and should set up a permanent knowledge source instead.

One framing note up front: Macha is an AI agent layer that sits on top of your helpdesk (Zendesk, Freshdesk, Gorgias, Front), not a helpdesk itself. Chat is where you build, test, and talk to those agents — and where attachments are the fastest way to give an agent context it doesn't already have.

The basics: drag, drop, send

There are two ways to attach a file to a message: drag and drop it onto the input, or click the file picker and browse for it. Either way, the file rides along with your next message, and the agent processes it as part of that turn.

Three categories are supported, and each is handled differently under the hood:

The distinction matters because it changes what the model actually receives. A document becomes text. An image becomes pixels the model can see. Audio becomes a transcript. Let's take them one at a time.

Each attached file shows up as a chip with its type icon, name, and size, plus an × to drop it before you send — so you can stage several files in one message and prune anything you grabbed by mistake.

How this compares to other AI chat tools

If you've used a general-purpose AI chat, attaching files will feel familiar — the mechanics are now table stakes. Where tools differ is in limits and in what happens next. A quick, honest ballpark from the consumer tools most people know (numbers as published in 2026, treat as approximate — vendors change them often):

The pattern is consistent: every one of these tools eventually runs into the model's context window, not an arbitrary file-count rule. The difference with Macha is the destination. In a consumer chat, the file's content informs an answer and stops there. In Macha, the extracted text, the vision read, or the transcript becomes context an agent can act on — drafting a Zendesk reply, posting to Slack, or generating a file back out. That support-ops loop is the point, and it's covered more below.

Is there a file-size limit?

Macha doesn't publish a hard per-file byte cap for chat attachments, and in practice you won't hit one with the files real support work involves — a contract PDF, a screenshot, a few minutes of audio. The real constraint isn't disk size, it's the model's context window. For documents specifically, the extracted text has to fit alongside your message, the agent's system prompt, its knowledge, and the rest of the conversation. A short PDF is nothing; an 80-page contract can crowd everything else out and degrade the answer.

So the practical "limit" is a budget, not a ceiling:

• Documents are bounded by tokens, not megabytes. Attach the relevant pages, not the whole binder, and a long document is a signal it should be a knowledge source (chunked and searched on demand) rather than pasted into one turn.
• Images are read as vision content, so a normal screenshot or photo is fine; absurdly large images cost more tokens and add latency.
• Audio length drives transcription time and cost — a voice memo transcribes fast, a 90-minute recording is more work.

If you need to work with something genuinely large repeatedly, that's the knowledge-source path, not a chat attachment — see the watch-outs.

Documents: text extraction into context

When you attach a PDF, DOCX, CSV, or XLSX, Macha automatically extracts the text and injects it into the conversation context. You don't paste anything; the words from the file simply become available to the agent for that conversation, alongside your message.

That makes the obvious questions trivial:

• "Summarize the key terms in this contract." (attach the PDF)
• "Which of these 300 orders are flagged for review?" (attach the spreadsheet)
• "Draft a reply to this customer based on the policy in this doc." (attach the policy)

Because the content lands in context as text, the agent can quote it, reason over it, cross-reference it against a connected tool, or use it to draft a response. A CSV of orders becomes something the agent can filter and count; a DOCX policy becomes something it can apply to a specific ticket.

Two practical limits worth knowing. First, extraction pulls text, so a scanned PDF that's really just images of pages won't yield much — for that you want the image path (below) or proper OCR upstream. Second, very large documents consume context: a single 80-page PDF can crowd out the rest of the conversation. If a document is something you'll reference repeatedly, it belongs in a knowledge source, not pasted into every chat — more on that in the watch-outs section.

Images: the agent actually looks

Attached images don't get flattened into a text blob and discarded — they're sent to the model as vision content, so a vision-capable model genuinely sees the picture. That's the same capability Macha agents use when they encounter an image attachment on a Zendesk ticket: the agent downloads the image, encodes it, and passes it to the model for visual analysis.

In practice the agent can:

• Describe a screenshot a customer sent of an error or a broken UI state
• Read text inside an image — a label, an error dialog, a handwritten note
• Identify a product from a photo
• Parse a receipt or invoice into structured fields

Vision is only as good as the model behind it. As of the April 2026 vision release, the vision-capable models include GPT-5.4 Mini, GPT-5 Mini, GPT-4o Mini, Claude Sonnet 4.5, and Claude Sonnet 4. If your agent is set to a model without vision (some Groq models, for instance), it will gracefully tell you image reading isn't supported rather than silently ignore the picture — so if an agent "can't see" your screenshot, check the model selector first.

This is the same engine behind reading image attachments on tickets — we go deeper on what the model can and can't reliably pull from a picture in How AI vision reads screenshots, receipts & product photos.

Here the agent didn't just acknowledge a file — it pulled ERR_PAYMENT_DECLINED_402, order KTD-48817, and the support reference straight out of the pixels, then quoted the full error text. That's vision doing OCR-grade reading on a screenshot a customer might paste into a ticket.

Audio: transcription as a tool action

Audio is the one that surprises people, and it works differently from documents and images. Speech isn't handled by the base model — it runs through the ElevenLabs connector's Transcribe Audio tool, an AI-powered Speech-to-Text action. The tool takes an audio or video file (it accepts MP3, WAV, M4A, MP4, WebM and other common formats), returns the full transcript as text, and that transcript becomes context the agent can summarize, mine for action items, or reply to.

Two things follow from how this is built. First, it's a tool, not a built-in — the ElevenLabs connector has to be connected (you paste an ElevenLabs API key once, as shown above) before an agent can transcribe anything. Documents and images work out of the box; audio depends on this connector. If you ask an agent to transcribe before it's connected, it will tell you it doesn't have that capability rather than guess — so the connector is step one.

Second, because transcription runs as a tool call, it surfaces live the way every Macha tool call does: the chat shows a real-time status while the tool executes ("Using Transcribe Audio"), then the transcript lands in the conversation as plain text. From there you can immediately follow up — "pull out the three commitments we made" or "draft a recap email." The tool is designed to take a file by URL — for example, an audio attachment already sitting on a Zendesk ticket — which is exactly the support-ops case: a customer leaves a voicemail, it lands on a ticket, and the agent transcribes and acts on it without anyone hitting play.

That's the difference between a generic chat that accepts an audio file and a support agent that can act on it: the transcript doesn't dead-end, it flows into the next step — a Zendesk reply, a Slack message, a row in a spreadsheet the agent generates. See the integrations directory for the ElevenLabs connector.

Where the credits go

Macha bills in credits, per AI action — not per file and not per "resolution." Attaching a file isn't itself a charge; the cost comes from what the model does with it.

• Documents add extracted text to context, so they're billed as part of the normal message response — credits depend on the model you've selected (roughly 0.5–9 credits by model, with the default GPT-5.4 Mini at the low end).
• Image vision is processed by the same response, on a vision-capable model.
• Audio transcription is a separate tool action (Transcribe Audio), so it consumes credits for that action in addition to the response that uses the transcript.

The honest takeaway: large documents and long audio files cost more because they involve more tokens and more work, not because attachments carry a surcharge. If you're cost-conscious, attach the relevant pages rather than the whole binder, and pick a lean model for routine extraction. Full per-model credit costs live on the pricing page, and you can try all of this on the 7-day free trial, no credit card required.

One-off uploads vs. permanent knowledge

This is the most important decision, and it's easy to get wrong. Chat attachments are per-conversation: the file is context for this chat, and Macha automatically cleans it up — conversations auto-delete after 45 days of inactivity, and chat attachments expire automatically. That's exactly what you want for a one-time question. It's exactly what you don't want for a document the agent should always know about.

If you find yourself attaching the same return policy, the same pricing sheet, or the same troubleshooting guide over and over, stop. That content belongs in a knowledge source, where the agent searches it on every relevant conversation without you re-uploading anything.

Macha's knowledge layer handles size intelligently: small files are injected directly into the prompt, while larger files are chunked, embedded, and searched on demand — so a 200-page manual stays usable without flooding context. You can also connect Google Docs and Notion pages as live sources, so when the underlying document changes, the agent reads the latest version automatically — no re-uploading. For the full picture of uploads, crawls, and live sources, see Giving agents knowledge: uploads, website crawl & live sources.

A simple rule of thumb:

For the full setup, see the Macha docs.

Closing the loop: files out, not just in

Attachments are the input side. It's worth knowing the output side exists too, because a lot of real workflows need both. Macha's File Tools connector lets agents generate files on the fly — XLSX spreadsheets, CSVs, PDFs, and DOCX documents — with no setup required. So a complete workflow can look like: attach a messy spreadsheet → the agent cleans and analyzes it → the agent hands back a tidy CSV or a formatted PDF report. Files in, files out, no leaving the chat.

Watch-outs and when not to use it

A few honest limits so this doesn't bite you:

• Scanned documents are images, not text. A "PDF" that's really photos of pages won't text-extract well. Treat it as an image (vision) or run OCR before uploading.
• Don't paste a knowledge base into every chat. Re-attaching the same big document is slow, expensive, and forgetful. Make it a knowledge source once.
• Audio needs the ElevenLabs connector. Documents and images work immediately; transcription doesn't until that connector is enabled.
• Vision needs a vision-capable model. Check your agent's model if it "can't see" an image — a non-vision model will say so rather than guess.
• Very large files eat context and credits. Attach the pages that matter, not the entire archive. For routine extraction, a leaner model keeps costs sane.
• Attachments are ephemeral by design. They expire with the conversation. If you need a permanent record, the source of truth should live in your helpdesk or a knowledge source, not in a chat attachment.

FAQ

What file types can I attach to a Macha chat? Documents (PDF, DOCX, CSV, XLSX), images (JPEG, PNG, GIF, WebP), and audio files. Documents are text-extracted into context, images are sent to a vision model, and audio is transcribed.

Does the AI actually read images, or just file names? It reads the image. Uploaded images are sent as vision content to a vision-capable model (GPT-5.4 Mini, GPT-5 Mini, GPT-4o Mini, Claude Sonnet 4.5, or Claude Sonnet 4), so the agent can describe screenshots, read text in the image, identify products, or parse a receipt.

How do I attach a file? Drag and drop it onto the chat input, or use the file picker. The file is processed with your next message.

How does audio transcription work? Audio is transcribed by the ElevenLabs connector's Transcribe Audio tool. You'll see a "Using Transcribe Audio" status while it runs, then the transcript becomes text the agent can summarize or act on. The connector must be enabled in your workspace.

Do attachments cost extra credits? Attaching a file isn't a separate fee — credits are charged per AI action. Document extraction and image vision are part of the message response; audio transcription is its own tool action and consumes credits accordingly. See pricing for per-model costs.

What happens to my files after the chat? They're ephemeral. Conversations auto-delete after 45 days of inactivity and chat attachments expire automatically. For content the agent should always know, use a knowledge source instead.

When should I use a knowledge source instead of an attachment? Whenever the same document needs to be available across many conversations — a policy, FAQ, or manual. Knowledge sources are searched automatically and support live Google Docs and Notion pages that stay up to date.

Ready to hand your agents real files instead of describing them? Start a 7-day free trial, no credit card required and try documents, images, and audio in chat, or read the chat documentation.