Live Data Sources vs Uploaded Files: Which to Use When

It's a small choice with outsized consequences. Pick wrong and you get the worst failure mode in support automation: an agent that answers confidently from a document that quietly went out of date three weeks ago. This guide is the decision framework — what each option actually is inside Macha, the trade-offs, and a simple rule for which to reach for in each situation.

Both arrived in the Agent data sources release (changelog, Feb 22 2026), and both live on the same Sources screen.

The two ways knowledge gets into an agent

Uploaded files (a point-in-time snapshot)

You upload a PDF, spreadsheet, or document and Macha turns it into a knowledge source. What happens next depends on size:

• Small files are injected directly into the prompt. The agent sees the full text on every request — nothing is retrieved or ranked, so there's zero chance the relevant passage gets missed. It's the most reliable form of "the agent just knows this."
• Larger files are chunked, embedded, and searched on demand. Macha splits the document into segments, embeds them, and at question time retrieves only the chunks that match. That's classic retrieval-augmented generation — it lets a 200-page manual fit a model that could never hold it all at once.

The defining property of an upload is that it's a snapshot. It reflects the file exactly as it was the moment you added it. If the underlying document changes next week, the agent keeps answering from the old copy until you re-upload.

Live connector sources (always current)

The alternative is to connect a live source: a Google Doc, a Notion page, or a Confluence page. Instead of copying the content into Macha, you point the agent at the document in the system of record, and it reads the latest version in real time. No re-uploading when the doc changes — edit the source, and the next ticket the agent handles already reflects the edit.

This is the difference most RAG teams learn the hard way: when your index lags the source of truth, the agent doesn't know it's wrong — it answers stale information with full confidence, and the customer has no way to tell. Live sources close that gap by design, because there's no separate copy to fall behind.

There's a third source type on the same screen worth knowing about — website crawling — for when your canonical answer lives on a public help-center or marketing page rather than in a doc.

The decision: a simple rule

Here's the short version, then the nuance.

**Upload a file when the content is stable and you own the cadence. Connect a live source when the content changes and someone else owns the cadence.**

That single distinction — who controls when this changes, and how often — settles most cases.

A useful way to internalize it: uploads optimize for control and reliability; live sources optimize for freshness and zero maintenance. When a wrong-because-stale answer is expensive (anything touching money, dates, or eligibility), freshness wins. When the content is genuinely settled, the simplicity and prompt-level guarantees of an upload win.

Why "small file = injected, large file = retrieved" actually matters

This isn't a trivia detail. A small uploaded file is the most dependable knowledge you can give an agent — every word is in context on every call, so there's no retriever to misfire. The moment knowledge crosses into chunk-and-retrieve territory (large uploads and live sources both ultimately retrieve), you inherit the classic RAG sensitivities: if a document is one 8,000-word wall of text, chunking can split an exception clause from the rule it modifies, and the agent may surface one without the other.

The practical takeaway: for the handful of things an agent must always get exactly right — your escalation rules, your refund eligibility, your one-paragraph brand voice — prefer a short, tightly-written uploaded doc over a giant catch-all. Save retrieval (large uploads and live sources) for the long tail.

Scope filtering: don't give every agent everything

Whichever source type you choose, Macha lets you scope what an agent sees: include all documents from a source, or hand-pick specific ones. This matters more than it sounds.

A billing agent doesn't need your entire engineering wiki — feeding it everything dilutes retrieval (more chunks to compete over) and risks the agent answering from a doc that was never meant for customers. Scope each agent down to the sources it should actually reason over, and both accuracy and predictability improve.

A common, clean pattern:

• Live source for the volatile, shared truth (pricing, promos, hours) — one connected Notion page, scoped into every customer-facing agent.
• Small uploaded files for each agent's non-negotiable rules (its escalation matrix, its tone guide) — scoped to only that agent.
• Large uploaded files for deep reference (the full product manual) — available to the agents that need depth, omitted from the ones that don't.

Watch-outs and when not to reach for a live source

Live sources are not a free win in every case. Be honest about these:

• A live source is only as fresh as the document behind it. If the Notion page is itself out of date, "live" just means the agent is reliably wrong. Live syncing doesn't fix governance — it makes whoever owns the doc responsible for accuracy. The field consensus is blunt: a knowledge base without ownership is a liability, not an asset.
• It adds a dependency. A connected source relies on the connector and the external service being reachable. An uploaded file has no such runtime dependency — it's stored. For something that absolutely must be available even if an integration hiccups, an upload is the safer floor.
• **Don't connect a huge live source for a tiny always-true fact.** If the agent must never miss a one-line rule, a small injected upload beats a live source whose retriever could, in theory, not surface that line. Match the mechanism to how critical the content is.
• Snapshots can be a feature, not a bug. For contracts, signed policies, or anything where you specifically want the agent reasoning over the version as of a date, an upload is correct — you don't want it to silently change.

Notably, you don't have to choose globally — you choose per piece of knowledge. Most mature setups mix all three source types. The skill is matching each one to the volatility and criticality of the content.

How this fits the rest of Macha

Data sources are passive knowledge — what the agent reads. They're distinct from connectors and tools, which are what the agent does (look up a Shopify order, post to Slack, issue a Stripe refund). A great agent usually needs both: a live Notion policy source so it knows what the refund rule is, plus a Stripe tool so it can act on it. If you're wiring up the action side, the Notion and Google Workspace integration pages cover what those connectors can read and write, and the data sources docs walk through adding each source type step by step.

Cost-wise, adding a data source doesn't cost credits — credits are spent per AI action, when an agent actually runs (0.5–9 credits by model, with the default GPT-5.4 Mini at 1). So you can attach the knowledge an agent needs without worrying that the attaching is what runs up a bill; see the pricing page for the full picture.

FAQ

What's the actual difference between an uploaded file and a live source? An uploaded file is a point-in-time snapshot — the agent reads the content exactly as it was when you added it, until you re-upload. A live source (Google Docs, Notion, or Confluence) is read in real time, so edits to the source are reflected on the very next ticket with no re-uploading.

When should I upload a file instead of connecting a live source? When the content is stable (a finished policy, a product manual, a one-off export) or when it's a short, critical doc the agent must never misquote — small uploaded files are injected whole into the prompt, which is the most reliable retrieval you can get.

Do large files get handled differently? Yes. Small files are injected directly into the prompt so the agent sees everything. Larger files are chunked, embedded, and retrieved on demand, which is what lets a long manual fit a model that couldn't hold it all at once.

Which tools can be live sources? Google Docs, Notion, and Confluence pages today, plus website crawling for public URLs. Uploads accept PDFs, spreadsheets, and documents.

Can I limit which documents an agent sees? Yes — scope filtering lets you include all documents from a source or hand-pick specific ones per agent, so a billing agent isn't reasoning over your engineering wiki.

Does adding a data source cost credits? No — credits are spent per AI action when an agent runs, not for attaching knowledge. See pricing.

The bottom line

The choice between uploaded files and live data sources comes down to one question: does this content change, and does someone else control when? If yes, connect it live so the agent is never quietly wrong. If it's settled — or if it's a short rule the agent must reproduce exactly — upload it. Most real deployments use both, scoped tightly per agent. Want to try it on your own docs? Start a 7-day free trial, no credit card required, connect a Notion page or upload a policy PDF, and watch an agent answer from it — then change the doc and watch the answer update.

Written by Abbas (Customer Support & AI, Macha) · Reviewed by Ankeet Guha (Co-founder & CTO) · Published 2026-06-24 · Last updated 2026-06-24.