Skip to content
Pipelex

For developers

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.

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.

    • Deterministic and testable
    • Weeks to production, 80% boilerplate
    • Developers only
  • The sweet spot

    Methods

    Structured freedom. Open standard.

    • Typed schemas, validated before runtime
    • Hours to production, zero boilerplate
    • Portable, no vendor lock-in
  • Agent Skills

    Total freedom. No guarantees.

    • Different result every run
    • No validation, no testing, no audit trail
    • Quality varies wildly

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

From business logic to executable method

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.

hr_screening.mthds
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
"""
Method definitionFlowchart
One method, two views: the .mthds file your experts can read, and the process Pipelex runs. Drag the slider to compare.

Input, deterministic orchestration, output

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

What comes in

  • Documents and PDFs
  • Images
  • Text, Markdown
  • Web sources

Deterministic orchestration

How the work is done

  • Typed steps
  • The right model for each step
  • Your business rules and branches
  • Every run traced, step by step

Output

What comes out

  • Structured data, images…
  • Decisions with their reasons
  • Reports and briefs
  • Answers for your agents

Where Pipelex creates value

Pattern 01

Extract, Retrieve, Answer

Turn hundreds of documents into structured data your systems can query.

Ingest → Extract typed concepts → Validate → Persist → Audit trail

  • KYC document bundles
  • Insurance policy contracts
  • Data room due diligence
  • Product spec sheets

Pattern 02

Collect, Analyze, Categorize

Web search, competitive intel and market scans, gathered, structured and categorized, under control.

Define → Collect → Filter and structure → Analyze → Categorize

  • Competitive intelligence
  • M&A target screening
  • Regulatory monitoring
  • Market sentiment

Pattern 03

Analyze, Decide, Follow-up

From inputs to a validated decision and a ready-to-send follow-up.

Ingest → Extract and structure → Apply rules → Decide → Trigger follow-up

  • Expense reports
  • RFQ go / no-go
  • Loan file review
  • Claims triage

The same artifact for every deployment

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.

your_method.mthds

Written in MTHDS, the open standard

  • Web appFor your teams
  • MCP toolFor your agents
  • APIFor your software

The MTHDS language

An open, typed, declarative standard. Readable like instructions, reliable like code. MIT License, you own it forever.

Auditable by non-technical people

Business experts can read the method and see what happened in each run, without reading Python.

Built to outlast change

Methods sit one level above models and interfaces. Swap a model or a channel without rewriting the method.

Orchestration

Durable execution for AI methods

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

Production breaks workflows in ways the demo never showed.

  • Models rate-limit and time out under real load.
  • A multi-step method dies at step 23 of 25, and you can’t tell what already ran.
  • Naive retries double-charge inference or duplicate side effects.
  • 5 documents is easy. 5,000 — or a hundred users at once — is a different problem.

How it works

Persist. Resume. Retry. Scale.

The same guarantees that power Temporal and Mistral Workflows, now for your methods.

Persist and resume

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.

Retry on failure

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.

Scale horizontally

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 on the orchestrator you already trust.

Temporal

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.

Mistral Workflows

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.

Pipelex Cloud

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

Built for teams, audited by IT.

  • Every AI method ships through real CI/CD: linted, formatted, schema-validated, and dry-run tested end-to-end without spending a token.
  • Fully configurable and extensible by your engineers.
  • Full visibility into every run, with no sifting through logs.

Ready to run Pipelex in production?

We’ll walk you through durable execution on your stack.

Install

Install the Pipelex plugin in Claude Code or Codex.

Pipelex is in private beta. Sign in and install the plugin with an API key from your console, or join the waitlist.

Paste this into Claude Code

Install Pipelex: run bash -c 'claude plugin marketplace add Pipelex/pipelex-plugins && claude plugin install pipelex@pipelex-plugins'. Then tell me to /reload-plugins.

Or paste this into your terminal

claude plugin marketplace add Pipelex/pipelex-plugins
claude plugin install pipelex@pipelex-plugins

Frequently asked questions

Everything you need to know about Pipelex and how it works.