Extract, Retrieve, Answer
Turn hundreds of documents into structured data your systems can query.
- KYC document bundles
- Insurance policy contracts
- Data room due diligence
- Product spec sheets
Describe how the work gets done in plain English. Pipelex turns it into a multi-step deterministic method: LLM, OCR, ImageGen… Deploy as a SaaS for your users, an MCP for your Agents or an API for your software.
Pipelex is built for work that reads, reasons about information and transforms it. Inputs come in, typed steps run in the same order every time, and structured results come out.
Describe the work in plain language. With the Pipelex plugin, your coding agent writes the method and shows you a validated flowchart before anything runs.

domain = "hr_screening"
description = "Analyze a job offer to build a scorecard, batch process CVs"
main_pipe = "screen_candidates"
# ── Concepts ──────────────────────────────────────────────
[concept.Criterion]
description = "A single evaluation criterion for scoring candidates"
[concept.Criterion.structure]
name = { type = "text", description = "Criterion name", required = true }
description = { type = "text", description = "What this criterion evaluates", required = true }
weight = { type = "number", description = "Importance 1-10", required = true }
[concept.Scorecard]
description = "Evaluation scorecard built from a job offer"
[concept.Scorecard.structure]
job_title = { type = "text", description = "Job title from the offer", required = true }
company = { type = "text", description = "Company name" }
required_skills = { type = "list", item_type = "text", description = "Skills required for the role" }
criteria = { type = "list", item_type = "concept", item_concept_ref = "hr_screening.Criterion", description = "Evaluation criteria" }
[concept.CvEvaluation]
description = "Complete evaluation of a candidate CV"
[concept.CvEvaluation.structure]
candidate_name = { type = "text", description = "Full name of the candidate", required = true }
overall_score = { type = "number", description = "Weighted score 0-100", required = true }
fit = { type = "text", description = "Whether the candidate fits", required = true, choices = [
"yes",
"no",
] }
strengths = { type = "list", item_type = "text", description = "Key strengths identified" }
weaknesses = { type = "list", item_type = "text", description = "Key weaknesses identified" }
[concept.CvResult]
description = "Final screening result for a candidate"
[concept.CvResult.structure]
candidate_name = { type = "text", description = "Full name of the candidate", required = true }
overall_score = { type = "number", description = "Weighted score 0-100", required = true }
fit = { type = "text", description = "Fit assessment", required = true, choices = [
"yes",
"no",
] }
outcome = { type = "text", description = "Routing decision taken", required = true }
# ── Main Pipe ─────────────────────────────────────────────
[pipe.screen_candidates]
description = "Screen candidates for a job offer"
type = "PipeSequence"
inputs = { job_offer = "Document", cvs = "Document[]" }
output = "CvResult[]"
steps = [
{ pipe = "extract_job_offer", result = "job_pages" },
{ pipe = "build_scorecard", result = "scorecard" },
{ pipe = "evaluate_cv", batch_over = "cvs", batch_as = "cv", result = "results" },
]
[pipe.extract_job_offer]
description = "Extract text from the job offer document"
type = "PipeExtract"
inputs = { job_offer = "Document" }
output = "Page[]"
model = "@default-text-from-pdf"
[pipe.build_scorecard]
description = "Build a scorecard from a job offer"
type = "PipeLLM"
inputs = { job_pages = "Page[]" }
output = "Scorecard"
model = "$writing-factual"
prompt = """Analyze this job offer and build a scorecard with weighted criteria.
@job_pages
"""
[pipe.evaluate_cv]
description = "Evaluate a candidate CV"
type = "PipeSequence"
inputs = { cv = "Document", scorecard = "Scorecard" }
output = "CvResult"
steps = [
{ pipe = "extract_cv", result = "cv_pages" },
{ pipe = "score_cv", result = "evaluation" },
{ pipe = "route_by_fit", result = "cv_result" },
]
[pipe.extract_cv]
description = "Extract text from a candidate CV"
type = "PipeExtract"
inputs = { cv = "Document" }
output = "Page[]"
model = "@default-text-from-pdf"
[pipe.score_cv]
description = "Score a candidate CV"
type = "PipeLLM"
inputs = { cv_pages = "Page[]", scorecard = "Scorecard" }
output = "CvEvaluation"
prompt = """Score the candidate on EACH criterion from the scorecard.
@cv_pages
@scorecard
"""
# ── Conditional Routing ───────────────────────────────────
[pipe.route_by_fit]
description = "Route a candidate CV by fit"
type = "PipeCondition"
inputs = { evaluation = "CvEvaluation", scorecard = "Scorecard" }
output = "CvResult"
expression = "evaluation.fit"
default_outcome = "handle_rejection"
[pipe.route_by_fit.outcomes]
yes = "handle_fit"
no = "handle_rejection"
[pipe.handle_fit]
description = "Build result for a candidate who fits the role"
type = "PipeLLM"
inputs = { evaluation = "CvEvaluation", scorecard = "Scorecard" }
output = "CvResult"
prompt = """Build a positive screening result for this candidate.
@evaluation
@scorecard
"""
[pipe.handle_rejection]
description = "Build result for a candidate who does not fit"
type = "PipeLLM"
inputs = { evaluation = "CvEvaluation", scorecard = "Scorecard" }
output = "CvResult"
prompt = """Build a rejection screening result for this candidate.
@evaluation
@scorecard
"""
Turn hundreds of documents into structured data your systems can query.
Web search, competitive intel and market scans, gathered, structured and categorized on a schedule.
From inputs to a validated decision and a ready-to-send follow-up.
Whatever the use case and wherever it runs, a method is one .mthds file: written in the MTHDS open standard, readable by your experts, run by Pipelex.
An open, typed, declarative standard. Readable like instructions, reliable like code. MIT License, you own it forever.
Business experts can read the method and see what happened in each run, without reading Python.
Methods sit one level above models and interfaces. Swap a model or a channel without rewriting the method.
Start in the Pipelex app, or from your coding agent with the Pipelex plugin. Describe the work, test it on real inputs, and deploy it when it is ready.
A luxury retailer · delivered through a Pipelex AI Sprint
About 1,000 customer quote requests a month, built by hand from supplier quotes. Strict pricing rules and templates meant quality depended on experienced staff, roughly one full-time position.
The pricing rules and quote template were encoded into one method, delivered to the team as a web app. The team reviews each generated quote before it goes out.
I can set up a clear method in minutes and actually see what’s happening. No more black-box prompts or guessing what went wrong.
Yannick TianStaff AI Engineer, GojobWe’re pushing toward 99% accuracy, the threshold where real automation becomes possible. Pipelex gives us the rigor to get there.
Adrien VesteghemChief AI Officer, MeilleurtauxAgents need a format they can reliably generate and execute — not free-form code. .mthds files are declarative, deterministic, and portable: agents write them, humans review them, Pipelex runs them. Python stays in the runtime; the method definition stays agent-readable.
MTHDS is an open standard for defining, packaging, and distributing AI methods. It has two pillars: the Language (typed concepts, pipes, and domains in .mthds files) and the Package System (versioned dependencies, lock files, cross-package references, and a federated registry at mthds.sh). The standard is maintained at mthds.ai and anyone can implement a runtime. Pipelex is the reference implementation.
Yes. MTHDS is an open standard with a public specification, not a proprietary format. Any platform can parse .mthds files, validate typed signatures, and execute methods. Pipelex is the reference runtime, but the standard is designed for broad adoption — your methods are never locked to a single tool.
Those are code-first frameworks with proprietary formats — humans write Python or TypeScript. Pipelex implements the MTHDS open standard: a portable, typed language with a real package system. Your methods aren’t locked to any runtime.
GUI-based platforms lock methods in their ecosystem. MTHDS methods are plain-text files — version them in Git with semantic versioning, compose them across packages with cross-package references, deploy them anywhere.
No. Pipelex provides deterministic methods that agents call as tools via MCP or API. We make agents reliable at repeatable business tasks — we don’t replace your agent stack.
Repeatable, deterministic AI tasks: invoice processing, contract analysis, report generation, compliance review. If it needs consistent results at scale, Pipelex fits. Not designed for creative exploration or open-ended tasks.
The MTHDS standard is open under the MIT license, and the SDKs, the plugins, the VS Code extension and the UI libraries are open source too. The Pipelex runtime, the runner API and the MCP server are source-available under the Elastic License 2.0: you can use them, build on them, embed them in your own products and run them on your own infrastructure, within the terms of the license. The main limitation is that you may not offer them to third parties as a hosted or managed service. Our license page explains how we read the license. Pipelex Business adds the managed platform on top: Studio, Cloud, Gateway and premium support.
Yes — the Pipelex AI Sprint is a fixed-price, 3-week engagement to ship three automations on your infrastructure. €20,000 (excl. VAT), contract-backed reliability threshold, and a 20% fee reduction if we miss it. See the AI Sprint section for the full offer.
You walk away with code, methods, and a Docker image — yours. Three paths from there: run it autonomously, keep an Extended Pipelex Support contract (monthly), or migrate to Pipelex Cloud when it launches. Sprint clients get priority access to Pipelex Cloud.
Heads of AI, AI Engineering leads, and COOs in regulated or sensitive environments — banking, insurance, capital markets/PE, freelance platforms — who need repeatability, handle document volume, want to keep control of the code, and can’t afford a 6-month build cycle.