PIPES
Your data dies in a warehouse.
Your team ships tables. Your competitors ship decisions.
Pipes is ETL built for the agentic era. Pull from any source. Clean. Score with AI. Decide. Act. All in one runtime. Your pipeline ships decisions, not tables.
THE PROBLEM
Your pipeline ends. The wait begins.
You pull. You clean. You load. Then your data waits. For a human to open a tab, draw a conclusion, pick up the phone. By the time anyone acts, the trade is gone, the customer churned, the alert too late.
Your warehouse
where signals die
Webhook lands
Becomes a row. Unqueried.
Schedule fires
Fills a table. Untouched.
Channel event
Indexed. Forgotten.
Form submits
Queued. Goes stale.
Manual run
Dashboard. Unread.
Every signal above is a moment your stack stored instead of acted on.
WHAT PIPES IS
One runtime. One brain.
Pipes is ETL built for the agentic era. A signal arrives. Pipes runs the pipeline you designed, with an AI that carries memory across every run. Pull. Clean. Score. Decide. Act. Audit. Every step your workflow needs. One runtime. One brain. Your data stops dying in warehouses. It starts shipping decisions.
Memory, skills, and tools available at every node you wire. Immutable workflow versioning (old executions keep replaying against their version). Saga branching with compensation. Replay any execution to any node checkpoint. Audit ledger by default.
Self-evolving workflows. The brain proposes improvements from thousands of prior executions. You approve. Your pipeline learns from itself, inside your guardrails.
One runtime. One brain. Every execution replayable. Every step you wire.
THE BRAIN
Four parts. One mind.
Every node you wire calls on the same brain. Memory of every prior execution. Skills as versioned code. Tools at the ready. An audit ledger that catches it all.
Memory that survives every run.
Every decision, every score, every action your pipeline ever made. Kept. The next run starts where the last one ended. By Monday, the brain knows your business.
Skills as code, not prompts.
Versioned. Testable. Replayable. Governed. The hard logic lives where engineers can read it, not buried in a prompt string inside a node.
Tools wired into every node.
Connectors, queries, side effects, model calls. The brain reaches for them at any step of the workflow you designed. Test before save so the credential is good before it ships.
Audit ledger by default.
Input, output, model, version, moment. Captured on every step. A regulator asks for last quarter's reasoning, you answer in one query.
WHEN A SIGNAL LANDS
From signal to shipped decision. In one execution.
The workflow you wired runs end to end. Memory, skills, tools, and audit are right there at every node.
Signal lands
A webhook, a channel event, a schedule, a form, a manual run. Whatever you wired as the trigger.
Brain wakes
Memory of every prior execution loads. Skills are ready to call. Tools are wired. The audit ledger opens.
Workflow runs
Every node you designed executes. Branch, transform, score, decide. Saga compensation if a step fails.
Decision committed
Input, output, model, version captured for every step. The audit ledger writes itself.
Action shipped
A trade placed. A customer alerted. A feed published. The decision lives in the world. Replayable forever.
Five lines of code. Your first event is live.
Authentication, encryption, delivery guarantees, and audit are handled for you. Connect to one product. Use the others when you are ready.
import { NPayload } from '@npayload/sdk'
const np = await NPayload.connect({
clientId: process.env.NPAYLOAD_CLIENT_ID!,
hmacSecret: process.env.NPAYLOAD_HMAC_SECRET!,
})
// Trigger a workflow execution
const exec = await np.pipes.workflows.trigger('wf_enrich_decide', {
input: { ticker: 'AAPL', price: 178.42 },
})SDKs in Node, Python, React, Browser. Public protocol documentation. Every event your team sends is inspectable.
What life looks like with Pipes.
Find the role that runs your morning. The change is for them.
One signal. A chain reaction.
Publishers enrich. Subscribers re-enrich. The marketplace compounds.
The publisher.
A data provider pulls raw market signals. The brain scores with memory of every prior tick. The enriched feed publishes to npayload Feeds. Buyers wire up and pay to consume. The pipeline becomes the revenue line.
The subscriber.
A quant firm consumes the publisher's feed. Pipes runs a private skill on top with the firm's own brain context. A derived signal publishes back to Feeds. Their subscribers wire to that.
The amplifier.
Every publisher seeds new subscribers. Some of those subscribers become publishers themselves. The brain grows in every direction. Your data becomes the substrate other people's businesses run on.
The replay request.
A regulator asks why a trade fired on March twelfth at 14:07. You don't dig through logs. You don't reconstruct state. You open the execution, scrub to the node, read the answer. Five minutes.
FOUNDING COHORT
Industries where the data is the product.
Teams in these sectors stopped shipping tables and started shipping decisions.
Financial services
Market data scored with memory of every prior tick. Trades placed in flight.
AI infrastructure
Model outputs, eval traces, training signals published as feeds. Audit follows every decision.
Insurance underwriting
Claims and applications scored mid-flight. Every reasoning chain replayable for the regulator.
Healthcare data
Patient signals joined, scored, routed with consent and audit baked in.
Logistics intelligence
Shipment events enriched with weather, customs, and route data. Decisions in seconds.
Marketplace data
Catalog feeds normalized, deduped, scored for ranking and ads.
Wire your first pipe.
Pull, clean, score, decide, act, audit. The pipeline you design ships decisions in the same execution.
Questions teams ask before they wire their first pipe.
Stop shipping tables. Start shipping decisions.
Pipes is ETL with a brain. Your data stops dying in warehouses. It starts shipping decisions.
Keep storing, or start shipping.