01
Configure
Patchr discovers dependencies, infrastructure, and required services automatically.
Work Execution Protocol for developers
Turn engineering intent
into executed work.
Patchr gives developers SDKs, protocol contracts, MCP/A2A surfaces, safe handoffs, and proof outputs for workflows that configure, validate, deploy, monitor, and repair software.
Build surfacesPython SDKNode.js SDKHTTP APIMCPA2A
work-execution.py
from patchr import Patchr
client = Patchr(api_key="pk_live_...")
# Validate a repository before release
result = client.run(
request="Check this repo for production readiness",
workflow="validate",
metadata={"repo": "github.com/acme/api"}
)
card = result.proof_card
print(result.route) # ["hunt", "resolve", "bridge"]
print(card.evidence_status) # "sourceBound"
print(card.recommended_action) # "fix_config_before_deploy"Execution Proof
Config checkedsource-bound tracedeploy blocked safely
The core platform surface for developer workflows
Python SDKNode.js SDKHTTP APIMCPA2A
How It Works
Configure, validate, deploy, monitor, repair.
02
Validate
Patchr verifies configuration, security, and deployment readiness.
03
Deploy
Patchr provisions and releases across environments.
04
Monitor
Patchr continuously watches health, performance, and reliability.
05
Repair
Patchr identifies and fixes issues before they become incidents.
Deploy-ready agents
Start with production-grade engineering agents.
These agents are built from the same Patchr core primitives developers use in the hackathon: SDK/API execution, connector boundaries, human-safe pauses, and proof outputs.
Configure
Environment Configurator
A production-ready setup agent that reads repo intent, finds dependencies and services, validates secrets, and returns a runnable environment plan.
Dependency mapService readinessProof card
Repair
Kubernetes Repair Agent
A repair agent for failing workloads that triages cluster state, isolates root cause, proposes scoped remediation, and preserves an approval trail.
Root-cause traceScoped fix planApproval-safe repair
Work Execution Protocol
One contract surface for executed developer work.
Public routes, schemas, manifests, events, and handshakes let workers discover what they are allowed to do before they act, then return proof of what happened.
Explore docsPatchr core platform
Intent
Turn goals into executable work
Natural-language requests
Domain routing
Contract discovery
Execution
Act through safe primitives
Hunt discovery
Proxy handoffs
Bridge connectors
Connectivity
Integrate without custom glue
HTTP API
MCP tools
A2A envelopes
Proof
Close with auditable outputs
Proof cards
Proof packs
Receipts
Hunt
Discover dependencies, services, work items, sources, risks, and evidence before execution starts.
Resolve
Validate requirements, reconcile contradictions, prune unsafe paths, and emit reviewable decisions.
Bridge
Connect repositories, CI/CD, cloud resources, SaaS tools, MCP tools, APIs, and webhooks.
Channels
Preserve durable state across developer inboxes, chat, issue threads, callbacks, and handoffs.
Cases
Coordinate formal workspaces with owners, deadlines, status timelines, evidence, and exports.
Proxy
Suspend autonomy for human approval, protected operations, manual checks, messaging, and proof capture.
Pay
Prepare outcome-based settlement with mandates, proof-of-value, receipts, and adapter-neutral rails.
Developer workflow layer
Configure, validate, deploy, monitor, repair.
Patchr applies the same protocol primitives to the software delivery lifecycle, so platform teams can build workers around real engineering outcomes.
Open developer quickstartConfigure
configureEnvironmentTurn a repo into a ready environment
Discover dependencies, required services, secrets, policy gaps, and setup blockers through Patchr contracts.
Validate
validateReleaseProve release readiness before deploy
Run evidence-backed checks, expose contradictions, and return proof-ready validation records.
Repair
repairWorkflowResolve a broken workflow with proof
Find root causes, coordinate safe action through Bridge or Proxy, and close with a portable proof card.
Packaged workflow examples
Use existing templates while you build core workers.
Procurement, due diligence, compliance export, and decision logging show how Patchr primitives compose into execution records with proof cards.
Vendor Due Diligence
Vendor due diligence in 1 day.
Source-bound vendor evidence, policy scoring, handoff trail, ROI summary, and a sealed proof pack.
Decision LogEvery option, every rejected path — preserved.
Log the full candidate set, rationale, and pruned paths in a portable record compatible with decision ledgers.
Compliance AuditTask record → audit-ready report.
Seal any completed task as a proof pack for a regulator, board, or legal review — one call, no write-up.
ProcurementHunt, verify, pay — receipt at the end.
Issue a spend mandate. The protocol enforces policy, executes settlement, and returns a finance-ready receipt.
Developer quickstart
Build against the platform surface.
Read the manifest, validate compatibility with a handshake, then run through SDK, HTTP, MCP, or A2A. Every surface is versioned and machine-readable.
Python SDKNode.js SDKHTTP APIMCP toolsA2A envelopesJSON Schemas
Hosted protocol checks
curl https://api.patchr.co/v1/manifest curl https://api.patchr.co/v1/protocol-map curl https://api.patchr.co/v1/workflows/templates curl https://api.patchr.co/v1/schemas
Sandbox
Watch work execute through the protocol.
Send a request and watch the orchestrator coordinate HUNT, RESOLVE, BRIDGE, PROXY, and PAY in real time with a live proof card at the end.
Open sandboxOrchestrator streaming
Watch domain events arrive in real time as the run progresses.
Domain handoffs
See which primitives were called, in which order, and why.
Shared tool traces
Inspect tool calls, connector reads, map lookups, and source attempts.
Proof-card output
Every run closes with evidence status, confidence, and a portable record.
Production use cases
For teams tired of glue work.
Environment automation
Move from clone to a working setup by discovering dependencies, services, secrets, and configuration gaps.
Learn moreRelease validation
Check build readiness, policy boundaries, deployment blockers, and evidence before a release moves forward.
Learn moreIncident repair
Discover root causes, coordinate remediation through connected systems, and return a proof trail.
Learn moreWhat builders say
Execution-first, proof-backed.
"Patchr turned our deployment checklist into a workflow our team can inspect. Every blocked path comes back with evidence, not a vague status."
PL
Platform Lead
Developer tools team
"The protocol map made integration straightforward. We could discover the surfaces, validate compatibility, and wire the SDK without guessing."
SB
Senior Backend Engineer
Infrastructure SaaS team
"The sandbox let us demo a repair workflow in an afternoon. The proof card gave us a clean way to show what happened and why."
PE
Product Engineer
Internal tooling team
Patchr core platform
Autonomous software delivery needs a work execution protocol.
Patchr turns discovery, validation, connectors, human-safe pauses, event trails, proof cards, and receipts into a reusable platform layer. Start with developer workflows, then expand the same protocol to external work.
Developer adoption
Automate painful setup, validation, deployment, monitoring, and repair workflows first.
Protocol moat
Keep SDK, API, MCP, A2A, schema, event, and proof surfaces consistent as workers expand.
Execution record
Close work with citations, decision logs, handoff trails, receipts, and portable proof cards.
Get started free