You send documents.Alembic sends back a colleague's work.
Not a pile of extracted fields — assembled customer files, honest morning check-ins, answers with citations, and decisions brought to you only when the call is genuinely yours to make.
What Alembic actually does
Eight capabilities between your documents and done. Each one built to save you time and earn your trust.
Every document about one customer, on one page.
Most document work isn't really about documents — it's about the company behind the certificate, the customer behind the bank statement, the case behind the filing. A space can now assemble everything you collect into one living profile page, merged from every document, filed automatically as each one processes. You step in only when a call is genuinely yours to make.
- A profile exists from the first document and fills in as the rest arrive — watch a customer file assemble in real time
- Every page knows what a complete file needs, and suggests what would fill the gaps in plain language
- Every value carries a badge naming the document it came from — click the badge and the source opens to that exact page
- When two documents disagree, the newest value wins visibly — one click shows every candidate, one more picks the winner
Your spaces report like colleagues.
The old world handed you a pile of flags and left the sorting to you. In Alembic, each space's agent works through its own open items first — resolving what the evidence supports, reconciling disagreements, taking another pass when better context appears — and then files one consolidated check-in. What reaches you is short, honest, and decidable.
- What the space handled on its own appears as itemized receipts, so you can see every action it took and check its work
- Each open decision is a card: the question in one line, two sentences of context, options written as plain actions
- Pick an option and the card shows the consequence in plain language before you confirm
- When your answer expresses a policy, it becomes lasting guidance — the same question never asks twice
Answers you can audit.
Language models are persuasive readers and unreliable accountants. Ask one to total a column in a dense report and it will answer confidently — and sometimes wrongly. The Analyst exists so that never has to be your problem: it reads tables structurally, does its arithmetic in a sandbox instead of estimating, and re-checks every number against the source page before answering. Available today as an API capability: one endpoint that streams progress and returns the cited, verified answer.
- Numbers are computed, not recalled — table math runs in a code sandbox, and the answer shows exactly what was added
- Every claim carries a citation: the page, the table, and the exact text it stands on
- Before an answer ships, a verification pass re-reads the source pages to confirm the values it rests on
- Effort scales with the question — and every answer reports how much work it took, so an expensive question is never a mystery
Your documents have answers. Alembic reads them like a person would.
Most extraction tools strip your PDFs down to raw text and pray the formatting survives. Alembic sends the actual document — layout, tables, handwriting, all of it — directly to AI that sees the page the way you do. Describe what you need in plain English, and the system designs the fields, extracts the data, and gets smarter with every correction.
- Vision-first processing — PDFs, scans, and images go straight to AI, not through lossy text conversion that destroys table structure
- Tell the AI what data you need in conversation, and it builds and refines the extraction for you — no templates, no training sets
- The right model for each task, automatically — fast models for simple fields, powerful models for complex reasoning
- Every correction you make becomes a permanent memory pattern, so the same mistake never happens twice
Every number has a receipt.
When your CFO asks "where did this figure come from?" you shouldn't have to dig through a filing cabinet. Every value Alembic extracts is pinned to its exact location — the page, paragraph, table cell, or line item in the source document. Click any field, see the proof. For regulated industries, that's not a nice-to-have — it's the whole point.
- Field-level source mapping links every extracted value to its exact position in the original document
- Visual highlighting shows you precisely where the AI found each data point — no ambiguity
- A full audit trail records what was extracted, when, by which model, and whether a human modified it
- Export source mappings alongside your data for compliance documentation and downstream audits
A space that builds itself in front of you.
A space used to begin with a form. Now it begins with whatever you have: an idea you can type, a document you can drop, or both. Alembic designs the fields and extraction around it while you watch, asks only when your answer would actually change what gets built, and shows you real extracted values before a single click confirms it.
- A live build that narrates itself — refresh, switch tabs, come back later; the feed picks up exactly where the build is
- Review real output, not a form: every creation ends with the values pulled from your document
- Nothing is final — fields, behavior, naming, and rules all stay changeable afterwards, in plain language
- Every space's page is composed around your data — ask for a different figure or layout and it reshapes
Trust the AI. Then check it against your own rules.
A model that is confident and wrong is worse than one that admits it isn't sure. So after extraction, your rules run — plain arithmetic and pattern checks, no AI involved and no tokens spent — and anything that fails them, or that the AI flagged as uncertain, comes to you before the data goes anywhere.
- Write the checks in your own terms: totals that must add up, dates that must fall in range, references that must match a format
- Rules are deterministic — the same document gives the same answer every time, and the check costs nothing to run
- Values the AI wasn't sure of are marked for review rather than asserted, so a guess never reaches your data silently
- Correct a value once and it becomes a lasting rule, so the same mistake stops recurring Pro
- Every extraction, correction and decision is logged and exportable
Use the UI. Or don't. The API does everything.
Alembic runs fully headless. Everything you see in the dashboard — uploading documents, building spaces, reviewing results, profiles and their gaps — is available through the REST API. If your system can make an HTTP request, it can run Alembic. Your own customer portal can show "2 of 6 documents in, here's what to send next" without building any of the logic.
- REST endpoints cover the full lifecycle — upload, extract, review, approve, export, and configure, all programmatically
- Webhooks push results, profile updates, completed files, and conflicts to your systems in real time
- Live streaming hands you each section the moment it lands, and Analyst answers stream back with their citations
- Batch uploads take up to 20 documents per call, each coming back with its own id and status — queue as many batches as you need
- Coming to Enterprise in Q4 2026: point Claude or any MCP-capable assistant straight at your spaces and ask about your documents from wherever you already work. Not running yet — today the API and SDK above do this job.
Two things Enterprise is buying that aren’t here yet.
Everything else on this page runs today. These two have a date instead, so you can plan around them rather than discover them missing.
Your documents, open to your AI tools
Arriving Q4 2026: point Claude or any MCP-capable assistant straight at your spaces and ask about your documents from wherever you already work. Until it lands, the REST API and TypeScript SDK reach the same data — they’re live on Pro and Enterprise now.
Sign in through your company identity provider
Arriving Q4 2026: SAML and OIDC single sign-on, so your team arrives with the accounts IT already manages and leavers are handled once, where they’re handled today. Until then, sign-in is email and password plus optional Google — on every plan, Free included.
What are you extracting?
Alembic handles any document type. Here are the ones our customers use most.
Invoices on autopilot
Vendor name, line items, PO number, due date, payment terms — extracted and validated before you finish your coffee. Let the data flow straight into your accounting system, matched and ready to pay.
Contracts without the squinting
Auto-renew clauses, termination dates, liability caps, payment schedules — surfaced instantly so you never miss a deadline that costs you money. Alembic reads the fine print so you can make decisions instead of highlighting PDFs at midnight.
Customer files that assemble themselves
Onboarding packets, KYC documents, statements, certificates — filed to the right customer profile as they arrive, with gaps and disagreements made visible. Your portal can show exactly what's still missing.
Claims, sorted in seconds
Policy number, claimant details, incident date, damage estimates, coverage limits — pulled from even the messiest scanned forms. Process claims faster, catch inconsistencies earlier, and stop losing hours to manual data entry.
Compliance without the chaos
License numbers, expiration dates, filing deadlines, regulatory classifications — tracked and structured automatically across every document in the stack. Stay audit-ready without dedicating someone's entire week to spreadsheet maintenance.
Your documents, your fields
Medical records, shipping manifests, permit applications, academic transcripts — if it has data, Alembic extracts it. Just tell the AI what you need and it builds the extraction on the fly. No templates, no training sets.
Seeing is faster than reading.
You just scrolled through everything Alembic can do. Now upload a document and watch it happen in about sixty seconds.
Start free