AI classification

It reads the document before it files it.

Findest doesn't match filenames or senders. Every attachment is read, compared against all of your rules at once, and filed under the one that actually fits. Or under none, and then it tells you why.

Inside the classifier

Five things happen between the inbox and the folder.

Plain checks run first

Before anything is sent to the AI, simple checks set aside what can't be a document: inline images, files under 3 KB or over 25 MB, and formats it can't read. Only what's left is classified.

In Findest
  1. Email with 5 attachments
  2. Inline, size and type checked
  3. 4 skipped, no AI involved
  4. 1 sent on to be read

The content, not the filename

A phone photo of a paper receipt is read just like a PDF, and Word or Excel files are turned into text first. What the document is, who issued it and when all come from what's printed on it.

In Findest
  1. IMG_2041.jpg opened
  2. Printed text read
  3. Type, issuer, date found
  4. Ready to compare

Why one request beats four

Asked about one rule at a time, a model has nothing to compare against and says yes to the first that looks close. Shown every rule together, it can tell them apart and pick the most specific.

In Findest
  1. One document
  2. Your 4 rules, numbered
  3. Sent in one request
  4. One number comes back

Kept, with the reason

When no rule fits, the answer is 0. The document is kept with the status No rule and the reason the model gave, right in your History. No guess, no approximate folder, no alert email.

In Findest
  1. Compared with every rule
  2. Answer: 0
  3. Reason saved to History
  4. Nothing filed by guesswork

Invoice, Factura or Facture

The document type, the summary and the reason are written in your account's language, so filenames read naturally to you. The rules you write stay exactly as you wrote them, in whatever language you chose.

In Findest
  1. Same invoice, three accounts
  2. Account language checked
  3. Type_Sender_Date written
  4. Filed under that name
The decision

One call. Every rule. Side by side.

Your rules aren't checked one at a time. They all go to the model together, in a single request, along with the document.

How to write a rule that wins

What actually gets sent

The document and every active rule, numbered. What comes back is a single number.

invoice-0412.pdf
1 · Electricity bills2 · Payslips3 · Signed contracts4 · Supplier invoices
One request: the document plus every rule
Answer: 4or 0, when none of them fit
1

Cost, the smaller reason

It is cheaper, and that matters. A Pro account with fifteen rules would otherwise mean fifteen requests for every document instead of one.

2

Accuracy, the real one

Asked “does this document fit this rule?” in isolation, a model has nothing to compare against, so it says yes to the first rule that looks vaguely close. Shown every rule at once, it can do what you actually want: tell them apart.

The answer is requested as structured output, so it's a rule number, not a paragraph that has to be interpreted. There is no ranking of your rules to maintain: the most specific fit wins.

Why it works this way

A bug filed an invoice in the wrong folder.

This isn't a hypothetical. The first version of the engine matched text, and it broke in a way that's worth showing rather than describing.

Before · substring matching
old engine
rule  = "facturas electricidad"
label = "factura"

rule.includes(label) → true

Every invoice looked like electricity

The rule, written in Spanish, meant “electricity invoices”. It captured every document the classifier labelled Factura (invoice), so a Make.com invoice landed in the user's energy folder. Not an edge case: that was the algorithm working exactly as designed.

Now · read and compared
current engine
rule = "Office electricity
  bills from Endesa. Not
  my flat, not gas."

doc read → no match

A sentence, checked against the page

The rule is a sentence, not a keyword, and the document is read against it. A software invoice no longer looks like an electricity bill just because both are invoices.

Keyword filters (sender, subject, filename) were removed outright rather than kept alongside the new engine. Two ways to route a document is one way too many, and the old one was the one that got it wrong.

Before the model

Most attachments never reach the AI.

Reading everything would be slow, noisy and needlessly expensive. A pre-filter runs first, and it's plain rules, not a model.

CheckWhat it catchesResult
inlineSignatures, logos and tracking pixels the mail client marks as inline.Skipped
< 3 KBToo small to be a real document. Almost always a decorative image.Skipped
> 25 MBAbove the size we accept, and above what's useful to classify.Skipped
typeAny format the model can't read, such as archives.Skipped
the restPDF, JPG, PNG, WEBP, HEIC, TXT and CSV are read as they are. Word (DOCX) and Excel (XLSX) files are converted to text first.Read

A newsletter with a logo in the footer costs nothing: the logo is discarded before a single token is spent. And because one broken attachment is handled on its own, it never stops the others in the same email from being filed.

When nothing fits

No match is an answer, not a failure.

If the model finds no rule that fits, it returns 0 and the document is kept with the status No rule, along with the reason the model gave.

That reason is visible in your History. It usually says something reasonable, and it's the fastest way to see that a rule needs rewording. Nothing is guessed, and nothing is silently dropped into an approximate folder.

You aren't emailed about it either. A document with no matching rule is normal operation; alerts are reserved for things that actually broke, so they stay worth reading.

What it doesn't decide

The document type is a label, not a decision.

Findest also works out what kind of document it is (invoice, payslip, contract) and uses it for the filename and for your History.

It used to decide routing too. It doesn't any more, and that's the whole point of the change above: the type is a description, and your rule is the instruction. Two documents of the same type can go to different folders, which is exactly what you'd expect and what the old engine couldn't do.

FAQ

Questions people actually ask.

See all questions

Which model does it use?

Gemini, configured server-side rather than hard-coded, so it can be changed without a release. It's asked for structured output, so the answer is a rule number, not prose that needs parsing.

Does my document get used to train a model?

No. The document is sent to be classified and the answer comes back; it isn't contributed to training.

What if two of my rules genuinely both fit?

The model picks one, and because it can see both, it picks the more specific one rather than whichever it happened to be asked about first. If they overlap so much that either would do, that's usually a sign they should be one rule.

Can I see why something was filed where it was?

Yes. Every document in your History carries the rule it matched, and documents that matched nothing carry the reason instead.

How long does classification take?

Seconds. The slow part of the whole journey is never the model — it's waiting for the mailbox to be polled, which is why documents arriving over IMAP take a few minutes to appear.