Executable AI Methods: the shared artifact for business, agents, and engineering.
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.
Business, agents, and engineering — finally working from the same file.
- Stop Writing Glue Code
- Stop Translating Business Logic into Python
- Stop Rewriting Code to Switch Models
- Stop Praying the Output Parses
- Stop Copy-Pasting Prompts Across Projects
- Stop Building Black-Box Pipelines
When agents automate business tasks, they're stuck between Writing Code and Writing Agent Skills
Code gives you control but takes weeks.
Agent Skills take minutes but give you no guarantees.
Business automation deserves better than this tradeoff.
Code
Total control. Total effort.
Methods
Structured freedom. Open standard.
Agent Skills
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.
From business logic to executable method
Define methods in declarative .mthds files. Version them in Git. Run them with one command.

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
"""
Built for AI workflows that read, reason about, and transform information.
Pipelex is purpose-built for AI-driven information processing. Here are examples of what teams build with the platform — from document extraction to decision automation.
Extract, Retrieve, Answer
Turn hundreds of documents into structured data your systems can query.
When this fits: When the business value is unlocking what’s trapped in unstructured documents.
Ingest → Extract typed Concepts → Validate → Persist → Audit trail.
Typical deliverable: API + Docker image feeding your downstream systems.
Design partnership running with a tier-1 French bank.
Analyze, Decide, Follow-up
From inputs to a validated decision and a ready-to-send follow-up.
When this fits: When the business value is replacing a manual review with a defensible, traceable decision.
Ingest → Extract & structure → Apply rules → Decide → Trigger follow-up.
Typical deliverable: Web UI for the analyst, or Agent Skill embedded in their existing tool.
Adjacent workflows running with two tier-1 French banks and a major staffing platform.
Collect, Analyze, Categorize
Web search, competitive intel, market scans — gathered, structured, categorized on a schedule.
When this fits: When the business value is converting noisy external signal into a recurring, structured brief.
Define → Collect → Filter & structure → Analyze → Categorize.
Typical deliverable: Pipelex Studio or scheduled push to Slack / email.
Same engine, same reliability commitment. Different deliverable shape.
Three AI automations. Three weeks. Your infrastructure.
When you’d rather not build it alone — we deploy our product at your place, in a tightly framed format, with a reliability target locked in at kickoff.
What we commit to
- Results-based commitment
- 3-week delivery, fixed price
- Deployed in your system
- 20% malus if we miss the threshold
How the 3 weeks run
- W1Scoping workshop + Workflow #1
- W2Workflow #2 + factoring of W1
- W3Workflow #3 + packaging & delivery
What you walk away with
- 3 production-ready automations meeting the agreed threshold
- Versioned .mthds methods + Docker image + Git repo
- Your format of choice: API, web UI, or agent skill
- 1 month of Pipelex Support, then full autonomy or Pipelex Cloud
Pick the deliverable that lands inside your stack. Same Sprint, same reliability commitment.
Not a consulting engagement. Our product, deployed at your place, in a tightly framed format.
What early adopters say
Teams already using Pipelex in production.

We’re pushing toward 99% accuracy—the threshold where real automation becomes possible. Pipelex gives us the rigor to get there.
“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.”
“Pipelex took us from idea to production in just three weeks. It’s so simple that even our intern was up and running in two days.”
Add Pipelex to Claude Code or Codex.
Install. Define. Execute. No boilerplate, no configuration, no lock-in.
Paste this into Claude Code
Install mthds: run bash -c 'npm install -g mthds && mthds-agent bootstrap && claude plugin marketplace add mthds-ai/mthds-plugins && claude plugin install mthds@mthds-plugins'. Then tell me to /reload-plugins.
Frequently Asked Questions
Everything 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.
Fully. The MTHDS standard and Pipelex runtime are MIT-licensed. The open-core model means enterprise features (managed cloud, advanced observability, certification) are commercial, but the runtime and the standard stay open.
Yes — the Pipelex AI Sprint is a fixed-price, 3-week engagement to ship three automations on your infrastructure. €20,000 (excl. VAT), reliability threshold contractual, 20% malus if we miss it. See the 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.
