Unsiloed AI: Felicis Bets $7.5M on Agent-Ready Documents
Your shiny AI agent is only as smart as the documents you feed it, and most real-world documents are a mess of merged table cells, scanned signatures, and footnotes that dissolve into word soup. Unsiloed AI is betting that cleaning up that unglamorous mess is worth more than yet another chatbot wrapper, and Felicis just put $7.5M behind the idea. The kicker? The whole company is seven people.
Unsiloed AI is a small startup that turns messy enterprise documents, like scanned invoices, multi-page tables, and charts, into clean, structured data that AI agents can act on reliably. Felicis has backed the company to build this document-parsing layer, betting that a focused specialist can outperform general-purpose models on accuracy and traceability.
This piece breaks down what Unsiloed AI is actually building, why “agent-ready documents” is more than a marketing label, and where the Felicis money is likely to matter most. You’ll also get a straight verdict on whether a seven-person team can survive a market already packed with tech giants and well-funded specialized startups. Spoiler: small isn’t automatically doomed. But it isn’t automatically scrappy-genius either, and that tension shapes everything below.
Here’s the context. AI agents are getting decent at reasoning, but reasoning over garbage input still produces garbage, just with more confidence. Hand an agent a scanned invoice where the line items have drifted into the wrong columns, and it will cheerfully approve the wrong total. That’s why document processing has quietly become one of the most contested layers in the AI stack: whoever turns messy PDFs into clean, structured data owns the pipe every agent drinks from. Unsiloed AI wants to own that pipe, and it’s walking into a very crowded room to do it.
What is Unsiloed AI, and Why Did Felicis Write a $7.5M Check?
The sexiest part of the AI agent stack turns out to be the least glamorous one: getting documents into a shape a machine can use. Everyone wants to demo an agent that reads your contracts, reconciles your invoices, and drafts the follow-up email before lunch. Almost nobody wants to talk about the fact that those contracts are scanned PDFs with coffee stains, the invoices have tables that span three pages, and half the critical data lives in a footnote. Unsiloed AI is building for that unglamorous middle layer, turning messy enterprise documents into what it calls agent-ready data, structured and clean enough for an AI system to act on without hallucinating its way through a balance sheet.
The problem is older than ChatGPT, and it’s still embarrassingly unsolved. Feed a large language model a raw PDF and it will cheerfully tell you something, which is not the same as telling you something correct. The usual failure points look familiar to anyone who has tried to ship a document workflow:
- Tables that get flattened into word soup, so row 4 and column C quietly stop being related
- Multi-column layouts read left-to-right across columns, splicing two unrelated paragraphs into one confident sentence
- Scanned pages, handwriting, stamps, and signatures that basic OCR treats as noise
- Charts and diagrams where the actual answer lives in the image, not the caption
Every one of those is a small parsing bug that becomes a large business error once an agent starts making decisions downstream. Garbage in, autonomous garbage out.
That framing is the clearest way to read Felicis’s $7.5M bet. Venture firms have poured money into model labs and flashy agent frameworks. The smarter money is now looking one layer down, at the data ingestion plumbing every agent depends on regardless of which model wins. If OpenAI, Anthropic, and Google keep trading benchmark crowns every quarter, the company that reliably converts a 200-page loan file into structured fields gets paid either way. It’s the pick-and-shovel play, except the shovels are parsers and the gold is buried in a SharePoint folder nobody has opened since 2019.
The obvious question is whether this is a company or a feature. Unsiloed isn’t walking into an empty room: tech giants and specialized startups already compete for the same job. And frontier models keep getting better at reading documents natively, which shrinks the gap a specialist has to fill. My take is that the gap doesn’t close as fast as the demos suggest. Reading a clean sample PDF is easy; hitting high accuracy across thousands of ugly, inconsistent, domain-specific files, with traceability back to the source page when an auditor asks, is a grinding engineering problem that general-purpose models aren’t optimized for. That reliability layer is where a focused startup can actually build a moat.
So $7.5M isn’t a moonshot check, it’s a wager on boredom winning. If enterprise agents are going to move from pilot purgatory to production, someone has to do the tedious work of making documents legible to machines, consistently and verifiably. Felicis is betting that someone is a specialist rather than a side feature in a foundation model’s API. Given how many agent projects quietly die the moment they meet real company files, that’s not a crazy bet. It might be the least hyped smart bet in the space right now.
Prerequisites and Requirements
Your Document Pile, Agent Stack, and a Way to Call an API
The most important prerequisite isn’t technical. It’s honesty about how ugly your documents really are. If your test set is three clean, digitally generated PDFs, you’ll get a glowing demo and learn nothing. Pull the files that actually break things: scanned invoices with coffee rings, 80-page contracts with nested tables, slide decks where the important number lives in a chart, and spreadsheets someone exported to PDF out of spite.
Next, know where the parsed output is going. A document pipeline built for agent-ready data only pays off if something downstream consumes it, whether that’s a retrieval setup in LlamaIndex or LangChain, a vector store like Pinecone or pgvector, or a custom agent loop built on the OpenAI or Anthropic SDKs. If you don’t have an agent stack yet, you’re evaluating a parser for a car you haven’t bought. Before you sign up for Unsiloed AI or any of its competitors, sketch the path from raw file to agent action, even if it’s just boxes on a whiteboard.
Finally, you need a way to make HTTP requests, which is a lower bar than vendors’ onboarding docs make it sound. For a first pass, this is enough:
- A terminal and curl for poking at endpoints and inspecting raw responses
- Python with requests or httpx (or Node with fetch) to script batch uploads
- A folder of 20–50 representative files, chosen for difficulty rather than convenience
- A place to diff outputs, such as a notebook or a JSON viewer, so you can compare parsers side by side
API Access, Keys, and Data-Handling Approvals From Security
The fastest part of this whole process is getting an API key. The slowest is getting permission to use it on real data. Documents worth parsing tend to be documents worth protecting: customer contracts, medical forms, financial statements, HR files. Sending them to a third-party API is a data-handling decision, and your security team will rightly treat it as one, regardless of how many venture dollars the vendor just raised.
Start the approval conversation on day one, not after you’ve fallen in love with the output. Security will want to know where files are processed and stored, how long they’re retained, whether they’re used for model training, what certifications the vendor holds, and whether a self-hosted or VPC deployment option exists. Ask the vendor for those answers in writing instead of trusting a marketing page. Meanwhile, keep your keys in a secrets manager such as AWS Secrets Manager, Doppler, or 1Password, rather than a .env file committed to a public repo. Everyone swears they’d never do that, but leaked keys in public repos are a well-known problem.
Step-by-Step Installation Guide
Step 1 — Request Access and Generate Your API Credentials
For an API-based document parser, setup typically means requesting access, getting a key, and deciding where that key lives. Put it in an environment variable or a proper secrets manager like AWS Secrets Manager, Doppler, or 1Password, not in a notebook cell you’ll accidentally push to a public GitHub repo at 11pm. Endpoint paths and auth headers change faster than blog posts, so pull the exact request format from the official docs rather than from anything you read here.
Step 2 — Pick a Representative Batch of Ugly Documents to Test
The demo PDF always works. That’s the job of a demo PDF. The real test is the pile of files that quietly wrecked your last retrieval pipeline, the ones your team stopped complaining about because complaining didn’t fix anything. Grab 20 to 50 of the worst offenders from your actual document store and resist the urge to clean them up first:
- Scanned invoices with coffee stains, skewed pages, and handwritten approvals in the margin
- Financial reports with nested tables that span page breaks
- Two-column academic papers where naive extractors interleave sentences from both columns
- Slide decks exported to PDF, where half the meaning lives in diagrams and callout boxes
- Contracts with footnotes, redlines, and repeating headers on every page
Step 3 — Send Your First Document Through the Parsing Endpoint
Send a single document first and read the output with your own eyes before you automate anything. The questions that matter are boring and brutal. Did the table survive as an actual table, with rows and columns intact, or did it turn into word soup? Is the reading order correct on multi-column layouts? Did page headers and footers get flagged as such, or are they about to pollute every chunk with “CONFIDENTIAL — Page 14 of 212”? Run the same file through whatever you use today, whether that’s PyPDF, Unstructured, or AWS Textract, and diff the results side by side. If you can’t see a difference on your ugliest file, you don’t have a reason to switch.
Step 4 — Pipe the Structured Output Into Your RAG or Agent Workflow
The whole point of structured output is that you stop chunking documents like a paper shredder. Fixed 512-token windows that slice a table in half are how you get an agent confidently quoting a revenue figure from the wrong quarter. Chunk on the document’s own boundaries instead: sections, tables, list blocks. Carry the metadata (page number, element type, parent heading) into your vector store, whether that’s pgvector, Pinecone, or Weaviate, so your agent can cite its sources instead of improvising. LangChain and LlamaIndex will both accept custom loaders, so wiring this in is an afternoon of work, not a quarter-long migration.
Then run the only benchmark that matters: your own eval set. Take the questions your agent botched last month, rerun them on the new pipeline, and count how many it now gets right. Felicis putting $7.5M behind “agent-ready documents” is a bet. Your eval results are the verdict, and they’re the only number in this whole exercise that applies to your data.
Configuration and First Run
Choosing Output Formats, Chunking, and Table Extraction Settings
Your output format decides what your agent can actually reason over. Pick Markdown and you get something an LLM reads comfortably, with headings and lists intact. Pick structured JSON and you get something your code can validate, route, and stuff into a database without regex. Most teams need both, so the real question is which one serves as your source of truth and which is a convenience copy.
Chunking strategy is where most RAG pipelines quietly fail. Fixed-size chunks, say every 512 tokens, are easy to reason about and terrible at respecting meaning. They will cheerfully split a contract clause from the exception that guts it. Semantic or layout-aware chunking, which breaks on section boundaries, headings, and logical units, costs more to compute and pays for itself the first time a user asks a question whose answer spans a page break. Before you touch any toggles, decide what a “unit of meaning” is in your documents:
- Contracts and policies: chunk by clause or numbered section, never by token count.
- Financial filings: keep each table whole and attach its caption and surrounding paragraph as context.
- Technical manuals: chunk by procedure, so step 7 never gets separated from steps 1 through 6.
- Scanned forms: preserve field-value pairs as atomic units instead of flattening them into prose.
Tables deserve their own paragraph because they cause most of the pain. Table extraction is the reason a startup like Unsiloed AI can raise $7.5M from Felicis while PDF parsers have existed for decades. Merged cells, multi-row headers, and tables that sprawl across three pages break naive extractors in ways that look fine at a glance and fall apart under scrutiny. If your settings let you choose between flattening tables to text and keeping them as structured rows and columns, keep the structure. An agent can’t reliably answer “what was Q3 revenue in the EMEA segment” from a paragraph-shaped soup of numbers.
Verifying Output Quality Against Your Source Documents
Your first run is not a success just because nothing crashed. Parsers fail politely: they return clean, well-formatted output that happens to be wrong, and clean-looking wrongness is the most dangerous kind. Pull your ugliest documents for the first test, not your nicest ones. That means the scanned invoice with a coffee stain, the 80-page 10-K with nested footnotes, and the slide deck someone exported to PDF with half the text sitting in images. If the tool handles those, the easy stuff will take care of itself.
Then do the boring work by hand. Open the source PDF and the parsed output side by side, and check a handful of specific things: do table totals still add up, are footnote markers attached to the right numbers, did reading order survive two-column layouts, and are headers and page numbers leaking into body text. Better yet, write ten questions whose answers you already know, run them through your agent, and see which ones it gets wrong and why. Eyeballing a dashboard full of green checkmarks doesn’t count as evaluation. Treat this golden set as permanent infrastructure and rerun it every time you change a chunking setting or the vendor ships an update, because silent regressions in document parsing don’t announce themselves until a customer finds them.
Common Errors and How to Fix Them
The most common failure in document pipelines for agents is assuming the PDF is the problem. It isn’t. The real problem is that teams treat extraction as a solved, boring step, pipe everything through PyPDF or a default loader, and then blame the LLM when the agent confidently reports that Q3 revenue was “Total.” A financial statement flattened into plain text is a word salad with numbers sprinkled on top, and no amount of prompt engineering will reassemble it. Garbage in, hallucination out.
The second error is naive chunking: splitting documents every 500 or 1,000 tokens because that’s what the tutorial did. Fixed-size splitters like LangChain’s RecursiveCharacterTextSplitter are fine for blog posts and terrible for contracts, where a single indemnification clause can span pages and a table header can end up in a different chunk from its rows. The agent then retrieves half a table and reasons from it with the serene confidence of someone who read only the first half of the email. Here’s what to do instead:
- Chunk by structure, not token count. Split on sections, headings, and complete tables so each chunk carries a full unit of meaning.
- Keep tables as tables. Emit Markdown or JSON with headers intact rather than flattened text, so an agent can actually look up a cell instead of guessing which number belongs to which column.
- Attach provenance to every chunk. Page number, section title, and source file let an agent cite its work, and let a human check it in ten seconds instead of ten minutes.
- Test on your ugliest documents first. Scanned invoices, two-column research papers, and slide decks exported to PDF will show you where the pipeline breaks long before your clean Word docs do.
Third: ignoring reading order. Multi-column layouts, sidebars, footnotes, and callout boxes get serialized left to right, top to bottom, which interleaves unrelated sentences into something that reads like a ransom note. OCR engines like Tesseract will happily give you every character on a scanned page in the wrong sequence. Fixing this takes layout-aware parsing that detects regions before extracting text. That’s exactly the unglamorous gap Unsiloed AI is betting on, and the $7.5M from Felicis is essentially a wager that “turn documents into something an agent can trust” is a product, not a weekend script.
The fourth error is the sneakiest: no evaluation of the extraction layer itself. Teams obsessively benchmark retrieval and answer quality but never check whether the parsed output matches the source. Build a small golden set: twenty or thirty real documents with hand-verified tables, fields, and section boundaries. Diff your parser’s output against it every time you change tools or settings. If you can’t say how accurately your pipeline extracts a line item from an invoice, you don’t have an agent problem. You have a measurement problem.
The general lesson is that document parsing has quietly become infrastructure, and infrastructure punishes shortcuts. Agents amplify whatever you feed them: clean, structured input makes them look brilliant, and mangled input makes them look like they’re improvising at a board meeting. The fix is rarely a bigger model. It’s treating the boring layer with the seriousness everyone reserves for the exciting one, because that boring layer is where most “AI failures” actually start.
Frequently Asked Questions
What is Unsiloed AI, and what does it actually do?
Unsiloed AI works in AI document processing, aiming to make documents usable by AI agents. Real-world documents are often full of tables, charts, and layouts that make LLMs hallucinate. Plenty of tools extract text. The hard part is keeping the structure: which number belongs to which table row, which footnote modifies which clause, and what reading order a two-column page actually follows. The underlying premise is that agents often fail less because of bad reasoning and more because of garbage input. That diagnosis is correct. Every team building document agents eventually discovers that parsing, not prompting, is where the bodies are buried.
How much did Unsiloed AI raise, and who’s backing it?
Unsiloed AI raised $7.5 million from Felicis. By current AI standards, $7.5M is a modest early-stage check. Nobody’s buying GPU clusters with it. It funds a focused team trying to win one painful layer of the stack. The signal matters more than the number. Felicis is betting that “agent-ready data” becomes its own infrastructure category rather than a feature that OpenAI or Anthropic quietly absorb into their APIs. That’s a reasonable bet, but not a guaranteed one, and it’s the main risk to watch.
How is Unsiloed AI different from OCR or tools like LlamaParse and Reducto?
Classic OCR, like Tesseract, gives you characters and maybe bounding boxes. That’s useful, but it’s dumb about meaning. Unsiloed competes in a crowded market of tech giants and specialized startups, many of which aim to output clean, structured data for RAG pipelines and agents. The competition is crowded, and honestly, the differences between these tools only show up on your documents. One handles nested financial tables beautifully and chokes on handwritten forms. Another does the opposite. Don’t trust anyone’s benchmark chart, including vendor marketing. Run a bake-off on your hundred ugliest files and let the results decide.
Is Unsiloed AI worth trying for my company?
It’s worth trying if you’re building agents or RAG systems on document-heavy workflows like finance, insurance, legal, healthcare, or procurement, and you’ve already noticed accuracy collapsing on real-world files. If your documents are clean digital text, you probably don’t need a specialist parser yet. Off-the-shelf libraries will do fine. Before committing, ask the boring questions: data residency, on-prem or VPC deployment, pricing per page at your actual volume, and what happens to your data after processing. Startups at this stage can move fast and customize for you. That’s a real advantage. The trade-off is betting on a vendor that hasn’t yet proven it will outlast the platform giants.
The Bottom Line
Everyone wants to talk about agents. Almost nobody wants to talk about the PDFs those agents choke on. That’s the real story behind Felicis putting $7.5M into Unsiloed AI. The bottleneck in enterprise AI isn’t model IQ. It’s the swamp of scanned contracts, nested tables, and forty-page decks that models are expected to reason over without hallucinating a decimal point. Garbage in, confident garbage out.
Still, $7.5M is a bet, not a coronation. Document parsing is a crowded field, and the frontier labs keep getting better at reading messy files natively. This only pays off if “agent-ready” turns into something defensible: reliability, structure, and provenance you can audit. A slicker OCR wrapper with a better pitch deck won’t cut it.
The direction is right, though. The next wave of AI winners may look aggressively boring: plumbing, pipelines, data hygiene. So before you sign off on another shiny agent platform, go look at what it’ll actually be reading. If your documents aren’t ready, neither are your agents.