Pattern 01
Extract, Retrieve, Answer
Turn hundreds of documents into structured data your systems can query.
Ingest → Extract typed concepts → Validate → Persist → Audit trail
For developers
Business describes the work. Agents (Claude Code, Codex) build the executable method with them — no engineering build cycle.
Engineering validates and deploys what ships. MTHDS is the file all three can read — typed, versioned, deterministic by design.
Pipelex runs it: in Claude Code or Codex, on your infrastructure, or in Pipelex Cloud.
Code gives you control but takes weeks.
Agent Skills take minutes but give you no guarantees.
Business automation deserves better than this tradeoff.
Total control. Total effort.
Structured freedom. Open standard.
Total freedom. No guarantees.
MTHDS is an open standard for declarative AI methods. Pipelex is its reference runtime — readable like instructions, reliable like code, ready in hours instead of weeks.
Build it with the agent you already use: Claude Code, Codex or your own agent
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
"""
.mthds file your experts can read, and the process Pipelex runs. Drag the slider to compare.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.
Input
Deterministic orchestration
Output
Pattern 01
Turn hundreds of documents into structured data your systems can query.
Ingest → Extract typed concepts → Validate → Persist → Audit trail
Pattern 02
Web search, competitive intel and market scans, gathered, structured and categorized, under control.
Define → Collect → Filter and structure → Analyze → Categorize
Pattern 03
From inputs to a validated decision and a ready-to-send follow-up.
Ingest → Extract and structure → Apply rules → Decide → Trigger 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.
Orchestration
Write your AI method once. We make sure it finishes through timeouts, rate limits, and crashes — whether you run it 5 times or 5,000.
The problem
How it works
The same guarantees that power Temporal and Mistral Workflows, now for your methods.
Every step’s state is captured as it runs. Nothing important lives only in memory.
After a crash or restart, the method continues from the last completed step. No lost progress, no double work.
Transient failures like rate limits retry automatically with backoff.
Deterministic errors stop cleanly, so you never burn inference repeating a doomed call. Tunable defaults decide which is which.
Runs fan out across as many workers as you need: across processes, across machines, across data centers.
A method you prototyped on a laptop can run on a whole fleet the same afternoon. Nothing to re-architect, nothing to rewrite.
Run it your way
Run Pipelex methods as Temporal Workflows with durable execution, automatic retries, and full visibility into every run.
Every API call runs as an Activity on a task queue, so you can rate-limit each provider or model and spread the work across multiple backends.
Leverage Mistral’s new orchestration layer for enterprise AI: durable execution, full audit trails, and human-in-the-loop approvals.
It’s in public preview and Pipelex already supports it.
Don’t want to host an orchestrator?
Run durable methods on our managed cloud, with nothing to operate and capacity that scales with your workload.
Production-grade by default
We’ll walk you through durable execution on your stack.
Pipelex is in private beta. Sign in and install the plugin with an API key from your console, or join the waitlist.
Install Pipelex: run bash -c 'claude plugin marketplace add Pipelex/pipelex-plugins && claude plugin install pipelex@pipelex-plugins'. Then tell me to /reload-plugins.claude plugin marketplace add Pipelex/pipelex-plugins
claude plugin install pipelex@pipelex-pluginsEverything you need to know about Pipelex and how it works.
Agents 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 VS Code extension and the UI libraries are open source too. The Pipelex runtime, the runner API, the MCP server and the Pipelex plugin for coding agents 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: the Pipelex app, Pipelex Cloud and premium support.