What's New in Macha — February 2026: Agent Data Sources & Credit Billing

If you joined Macha after the spring, these are the foundations under your feet; if you've been here a while, this is the changelog entry that turned "an agent that answers from a static prompt" into "an agent that reads your live docs." Here's exactly what changed, how each piece works, and where the sharp edges are. Everything below maps to the February 22 changelog.

Part 1: Agent data sources

Before this release, an agent's knowledge was whatever you typed into its instructions. That's fine for tone and rules of thumb; it's useless for the long tail of "what's our return window on opened products?" questions that make up most of a support queue. Data sources fix that by giving every agent a body of reference material it can read — and three different ways to feed it.

Knowledge base: upload documents

The simplest path: upload PDFs, spreadsheets, and documents directly as knowledge sources. What happens next depends on size, and the distinction matters more than it looks:

• Small files are injected directly into the prompt. The whole document rides along in context on every request — nothing is lost to retrieval, the agent sees all of it, every time. Best for a tight, authoritative doc (a one-page returns policy, a pricing sheet) you want the model to treat as ground truth.
• Larger files are chunked, embedded, and searched on demand. This is classic retrieval-augmented generation (RAG): the file is split into pieces, each piece is turned into a vector, and at question time the agent pulls back only the chunks that match. It scales to big manuals without blowing your context window — but the agent only ever sees the slices retrieval surfaces.

That second path is why how you structure a document matters. Retrieval quality lives and dies on chunking; as RAG practitioners put it, if you fix one thing, fix chunking — small chunks improve precision while large chunks preserve context-best-practices-for-enterprise-ai-chunking-embeddings-reranking-and-hybrid-search-optimization). A clean, well-headed document retrieves better than a 200-page PDF dump. If an agent keeps missing an answer that's "definitely in the doc," the doc is usually the problem, not the model.

Live connector sources: Google Docs and Notion

Uploads are a snapshot. The moment your policy changes, a static upload is stale until someone remembers to re-upload it. So this release also shipped live connector sources: connect Google Docs and Notion pages as data sources, and agents read the latest content in real time — no re-uploading when the document changes.

This is the right default for anything your team actively maintains. Keep your canonical returns policy in a Notion page or a Google Doc, connect it once, and every agent that references it is automatically current the next time someone edits it. The single most common knowledge-base failure mode in support — the bot confidently quoting a policy you changed three weeks ago — basically disappears when the source of truth is the document your ops team already edits.

The trade-off is the mirror image of uploads: live sources are only as good as the page behind them, and they depend on the connection staying healthy. A messy, half-finished Notion page makes a messy agent.

Scope filtering: not every agent gets everything

The third piece is quieter but it's what makes the first two usable at scale. Scope filtering lets you choose, per agent, between all documents from a source or a hand-picked subset. Your billing agent doesn't need the shipping playbook; your tier-1 triage agent shouldn't be reasoning over the internal incident runbook.

Narrow scope isn't just tidiness — it's accuracy and safety. Fewer, more relevant documents mean retrieval has less to get wrong and the agent has fewer ways to surface something it shouldn't. Treat data-source scope the way you'd treat permissions: give each agent the minimum it needs to do its job. The full mechanics live in the data sources docs.

Part 2: Credit-based billing

The other half of this release is how Macha meters usage. AI agents cost real money to run — every model call is tokens in and tokens out — and February 22 is when Macha made that cost visible and predictable instead of implicit.

How credits work

Macha bills on credits, with per-model pricing. Different models cost different amounts because they genuinely cost different amounts to run — a small fast model is cheap, a frontier reasoning model is not — and the credit cost per response reflects that. In today's lineup, credit cost ranges roughly 0.5 to 9 credits depending on the model, with the default GPT-5.4 Mini at 1 credit. You pick the model per agent and see the cost when you do.

The single most important detail, and the one that trips people up coming from other tools: credits are deducted once per complete assistant response — not per tool call, not per token, not per step. An agent that looks up an order in Shopify, checks a refund in Stripe, and writes a reply still costs one response's worth of credits. The work it does inside that turn is yours; you're billed for the turn.

That's a deliberate philosophy, and it's worth contrasting with the market. In 2026, credit and usage-based billing has become the dominant model for AI platforms, but the unit varies a lot. Intercom's Fin lists from $0.99 per resolution and Zendesk meters "automated resolutions" — both bill per outcome. Macha bills per action. We think that's the honest unit: Macha is automation and orchestration, and outcomes (a deflection, a resolution) depend on your setup, your data, and your customers — things a vendor charging per "resolution" is quietly pricing the variance of. Per-action means you pay for the work you asked the system to do, and the leverage of turning that work into resolutions stays with you. (More on that framing on the pricing page.)

One more rule worth knowing: Enterprise plans bypass all credit checks. At that tier the metering gets out of the way entirely.

Usage alerts: no end-of-month surprises

Credits only feel safe if you can see them draining. So this release added automatic email alerts at 50%, 80%, and 90% of your credit allowance. You find out you're burning fast on a Tuesday with room to react — bump a noisy agent down to a cheaper model, top up, or tighten a trigger — instead of discovering it when agents stop responding.

In-app checkout

Finally, billing moved in-app. You can subscribe and manage your plan directly inside Macha via Chargebee-powered checkout — no separate billing portal, no sales call to change tiers. The Professional plan sits at $699/mo with 10,000 credits a month; you can see exactly what a credit buys before you commit.

How the two halves fit together

These shipped on the same day for a reason. Data sources decide what an agent knows; credits decide what it costs to ask. Together they're the two dials every Macha deployment turns:

A well-scoped live source on a cheap default model is the sweet spot for most tier-1 work: current answers, low cost per turn, no surprises. You escalate to a pricier model only for the agents that genuinely need the reasoning.

Watch-outs

A few honest caveats, because both systems have edges:

• Chunked sources only see what retrieval returns. For a big uploaded manual, the agent reasons over the chunks that matched — not the whole file. If a critical answer keeps getting missed, restructure the document (clear headings, focused sections) before you blame the model.
• Live connectors inherit your doc's mess. A live Notion source is exactly as reliable as the page behind it. Half-written pages make half-right agents. Connect sources of truth, not scratchpads.
• Per-response billing rewards good design, not chattiness. Because you're billed per complete response, a tighter agent that resolves in one turn is cheaper than one that needs three back-and-forths. Cost and quality point the same way here, which is the point.
• Watch the model dial. The gap between a 1-credit default and a 9-credit frontier model is real. Don't put your highest-volume, lowest-complexity agent on your most expensive model out of habit.

FAQ

What's the difference between an uploaded source and a live connector source? An upload is a snapshot — it reflects the file as it was when you uploaded it, and it goes stale when the underlying doc changes. A live connector (Google Docs, Notion) reads the current content on every request, so the agent is always working from the latest version. Use live connectors for anything your team actively edits.

When does Macha inject a whole document vs. chunk it? Small files are injected directly into the prompt in full; larger files are chunked, embedded, and retrieved on demand. The cutoff is about fitting in context — a one-pager rides along whole; a long manual gets searched.

How are credits charged? Credits are deducted once per complete assistant response, with per-model pricing (roughly 0.5–9 credits by model; the GPT-5.4 Mini default is 1). All the tool calls and steps inside a single turn are covered by that one deduction. Enterprise plans bypass credit checks entirely.

Will I get warned before I run out of credits? Yes — automatic emails fire at 50%, 80%, and 90% of your allowance, so you can react before agents are affected.

Can I limit which documents an agent can read? Yes. Scope filtering lets you give an agent all documents from a source or a hand-picked subset — useful for keeping a triage agent away from internal runbooks.

Try it

If you want to see both halves working, start a 7-day free trial, no credit card required, connect a Notion or Google Doc as a live source, point an agent at it, and watch the credit cost per response as you test. The full mechanics are in the data sources docs, and there's more shipping every month on the blog.

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