CONDUIT is a self-hosted workflow automation platform. Connect Gmail, Slack, Notion, Google Sheets & WhatsApp, build AI agent workflows on your own data and models, and wire up 400+ apps with visual drag-and-drop — no Zapier subscription, zero data leaks.
Built as a private automation control plane, CONDUIT coordinates deterministic workflows, AI-assisted decisions, human approvals, audit trails, and protected handoffs across the systems your organization already trusts.
Drag a node onto the canvas, click an output port then an input port to wire them, and hit Run to watch data flow through your workflow — live, right here in the browser.
CONDUIT turns automation into an operating layer: source systems stay authoritative, workflows become inspectable, and every automated step can be traced from trigger to decision to final handoff.
Gmail, Slack, Notion, Google Sheets, WhatsApp, Stripe, GitHub, Postgres and hundreds more — plus a generic HTTP node for any API on earth.
Drop in LLM, agent and vector-store nodes. Bring your own data and models — OpenAI, Anthropic, or local Ollama — and let agents make decisions inside your flows.
Build branching, looping, multi-step automations on a canvas. No glue code required — but drop into a Code node whenever you want raw JavaScript.
Runs entirely on your own server or laptop. Your credentials and data never leave your infrastructure. Air-gap it if you like.
Schedules, webhooks, email arrivals, form submissions, file changes — kick off workflows the instant something happens.
Backed by 175,000+ GitHub stars. No seats, no per-task billing, no Zapier subscription. Fork it, extend it, ship it.
Codify repeatable operating procedures with explicit branching, typed payloads, validation checkpoints, and controlled exception paths.
Require approvals, restrict sensitive nodes, and gate privileged actions before records move, tickets open, or external systems are updated.
Maintain run logs, input/output snapshots, actor context, credential usage, retries, and terminal state for forensic review.
Ingest webhooks, feeds, PDFs, email, forms, and repositories; enrich them with extraction, classification, correlation, and review steps.
Chain specialist agents for triage, retrieval, summarization, validation, recommendation, and final human-in-the-loop disposition.
Monitor executions, latency, failure rates, queue depth, node health, and workflow drift before automation becomes operational risk.
CONDUIT is designed for teams that need automation to be inspectable, portable, and governed—not hidden inside a rented black box.
Workflows read from and write back to designated systems of record, preserving ownership boundaries instead of creating shadow operational data.
AI nodes can propose actions, draft outputs, and prioritize queues while approval nodes preserve accountability for operationally significant steps.
Every integration, transformation, credential, and model call is represented as a node that can be inspected, versioned, replaced, or forked.
A CONDUIT deployment separates orchestration, credentials, data stores, queues, workers, AI services, and observability so production teams can scale the layer without surrendering control.
Queue-backed runs, resumable execution, idempotent node patterns, and explicit failure states keep automation predictable under load.
Move work between agents, humans, and systems with structured payloads, mandatory context, and policy checks at transition points.
Normalize SaaS APIs, internal services, databases, and HTTP endpoints behind repeatable node contracts.
Insert schema checks, confidence thresholds, duplicate detection, source ranking, and manual review before irreversible actions.
CONDUIT expands from a visual builder into an automation command center: triggers, queues, approvals, agents, connectors, logs, and deployment controls operate as one self-hosted system.
API calls, webhooks, schedules, inbox events, forms, repository changes, and file drops enter through normalized trigger contracts with explicit payload shape and source metadata.
Version-controlled node graphs define branching logic, retry policy, secrets scope, approval checkpoints, AI model routes, and terminal states before execution begins.
Jobs move through queue-backed workers that support concurrency limits, delayed retries, resumable steps, dead-letter handling, and clean isolation between long-running automations.
Human approval gates, role permissions, policy-aware nodes, prompt governance, and audit events keep automation accountable even when agentic steps are embedded inside flows.
Modular integrations standardize SaaS APIs, databases, AI services, internal tools, and generic HTTP calls so teams can extend workflows without rebuilding orchestration primitives.
Execution history, node timings, payload lineage, error traces, queue depth, retry outcomes, and exported logs give operators a reliable view of what happened and why.
Every run follows an inspectable path: receive the event, evaluate context, execute deterministic steps, request approval when needed, and preserve the record.
CONDUIT keeps sensitive automation close to the systems it serves, with controls that support auditability, separation of duties, and disciplined AI use.
Store secrets inside your environment, scope them to workflows, and avoid third-party brokered execution for sensitive integrations.
Separate builders, operators, approvers, administrators, and auditors so production changes are not indistinguishable from routine use.
Forward run events, approval records, prompt versions, and integration outcomes into your logging and SIEM stack.
Pin model routes, approve prompt changes, record generated outputs, and require confidence thresholds before agent recommendations advance.
CONDUIT treats every automation as a traceable run: triggered by a real event, resolved through explicit logic, and completed with evidence attached.
Incoming events are normalized into structured payloads with actor context, source metadata, timestamps, and correlation identifiers.
Conditional logic, connectors, databases, AI-assisted steps, and confidence thresholds transform raw signals into operational decisions.
Human-in-the-loop checkpoints can require one or many approvers before customer, finance, security, or infrastructure changes proceed.
Jobs run through isolated workers, idempotency keys, retry policies, timeout controls, and terminal success or failure states.
Every node emits run evidence so teams can replay decisions, export history, diagnose failures, and improve future workflows.
Production workflows need more than happy-path execution. CONDUIT is positioned around durable state, explicit failure handling, and operational recovery.
Persist node inputs, outputs, status transitions, and terminal results so interrupted workflows can be inspected, resumed, or replayed.
Apply bounded retries, backoff, timeout limits, and dead-letter handling instead of infinite loops or silent background failure.
Track queue depth, worker health, execution latency, stuck jobs, and connector error rates before backlog becomes business risk.
Version workflow definitions, credentials, prompts, and approval policies so teams can roll back known-bad automation quickly.
Move execution history into analytics, SIEM, data warehouses, or compliance archives without relying on a vendor-controlled console.
CONDUIT keeps the visual builder approachable while preserving an engineering-grade escape hatch for teams that need custom connectors, reusable nodes, and version-controlled operations.
Wrap internal APIs, databases, queues, ticketing systems, model endpoints, and proprietary tools as reusable nodes with clear contracts.
Export definitions for review, promotion, backup, and source control so automation changes can follow the same discipline as application code.
Use schema validation, field mapping, and deterministic transforms to keep multi-step workflows stable as upstream systems evolve.
Attach model routes, prompt versions, retrieval sources, eval criteria, and approval requirements to agentic steps instead of burying them in ad hoc scripts.
Turn recurring operational procedures into reusable automations that engineering, security, support, finance, and leadership can safely operate.
CONDUIT is strongest where events, decisions, integrations, and accountability need to meet in one governed execution surface.
Route intake, update systems of record, reconcile spreadsheets, notify owners, generate status briefs, and escalate exceptions with approvals.
Trigger deploy checklists, triage incidents, enrich alerts, open tickets, rotate runbooks, and coordinate human review before risky actions.
Ingest findings, correlate identity and asset context, classify severity, prepare response packages, and preserve immutable evidence trails.
Qualify inbound leads, draft follow-ups, sync CRM records, alert sales, and require approval before sensitive customer communications.
Build private assistants that retrieve enterprise context, summarize documents, propose next actions, and hand off decisions to accountable humans.
Generic SaaS automation is convenient until credentials, regulated data, model prompts, or operational authority must leave your control plane.
CONDUIT places workflow design, credential custody, run execution, approval evidence, AI routing, queues, and observability inside your deployment boundary. That architecture keeps automation close to source systems, shortens feedback loops for operators, and gives technical buyers the right control points for scale, governance, and incident response.
| Decision angle | CONDUIT | Generic SaaS automation |
|---|---|---|
| Data and credentials | Private execution, environment-held secrets, local databases, exportable history, and optional air-gapped patterns. | Third-party execution boundary, external credential brokerage, vendor logs, and limited infrastructure control. |
| Governance and approvals | Multi-step approval flows, role-aware operation, audit trails, deterministic branching, and policy-aware privileged actions. | Workflow convenience first, with governance often added through separate tools or enterprise plans. |
| Extensibility and portability | Open-source modules, custom connectors, workflow definitions that can be reviewed, forked, backed up, and migrated. | Closed runtime, platform-specific limits, per-task billing pressure, and limited deep customization. |
Search the integration library. Every app speaks the same node language, so you can chain them however you want.
Run CONDUIT as a container with local persistence for small teams, labs, and controlled proof-of-value deployments.
Separate web, workers, database, and queue services to handle higher execution volume and isolate failure domains.
Deploy into Kubernetes, private cloud, on-prem infrastructure, or edge systems where data gravity and connectivity demand local execution.
Use the ClearGlass fleet when you want managed hosting, hardening, updates, backups, workflow buildout, and operational handoff.
CONDUIT is built around operational truth: integrations fail, payloads drift, APIs rate-limit, and human decisions matter. The platform makes those realities manageable.
Retry transient failures with defined limits, backoff windows, and escalation paths instead of silent infinite loops.
Route exhausted jobs into review queues with payload, node, error, timestamp, and workflow version preserved.
Track node timings, connector response, queue wait, model latency, and total execution time for bottleneck analysis.
Re-run failed branches with known inputs, patched credentials, or updated definitions while keeping prior history intact.
Launch cleanup, notification, rollback, or reconciliation flows when downstream systems reject or partially complete a step.
Technical teams can keep the visual builder for speed while extending the engine with custom nodes, internal APIs, model providers, and versioned automation packages.
Wrap internal services, proprietary data sources, validation routines, and domain-specific actions as reusable workflow blocks.
Use code nodes for transformations, signatures, payload normalization, scoring, and specialized logic that does not belong in a generic connector.
Trigger, inspect, export, and manage workflows through APIs so CONDUIT can sit behind portals, command centers, or internal developer platforms.
Route AI steps to approved commercial models, private endpoints, or local inference while preserving prompt versions and output lineage.
Promote definitions through review, staging, production, and rollback workflows so automation changes behave like software changes.
CONDUIT is broad enough for everyday automation and disciplined enough for work that needs approval, evidence, and recoverability.
Route form submissions, reconcile spreadsheets, enrich customer records, generate handoff packets, notify owners, and require approval before external communications.
Trigger incident workflows, open issues, query logs, summarize deploy changes, request rollback approval, and fan out status updates from one controlled run.
Ingest alerts, enrich indicators, classify severity, collect evidence, open cases, and keep containment actions behind explicit human authorization.
Connect databases, Slack, CRM, ticketing, docs, and AI copilots into approval-aware tools without waiting for a full custom app build.
Summarize operational signals, prepare decision briefs, track follow-ups, and preserve the evidence chain behind recommendations.
SaaS automation is useful for lightweight glue. CONDUIT is for teams that need ownership, auditability, and operational depth.
The more important the workflow, the less acceptable it becomes to lose control of credentials, latency, deployment timing, data retention, or audit evidence.
Run automation near databases, files, internal APIs, and private models without exporting operational context into a shared external runtime.
Network boundaries, identity systems, logging standards, retention requirements, and approval workflows can mirror how your organization already operates.
High-volume automation should not become a tax on every task. Self-hosting lets capacity planning replace unpredictable per-run economics.
CONDUIT is not only a canvas for connecting apps. It is an operational surface for understanding who triggered a run, what changed, which policy applied, where execution paused, and how to recover without losing the historical record.
Inspect run timelines by trigger, node, connector, model route, queue wait, retry attempt, approval decision, and terminal state. Operators can separate integration failure, data drift, model latency, and policy denial instead of debugging from a single generic error.
Scope users, teams, credentials, environments, and connector actions so a workflow can read broadly, write narrowly, and require approval before privileged side effects. UI access accelerates work; server-side policy remains the authority.
Replay a failed branch with the same input snapshot, patched credentials, adjusted retry policy, or a newer workflow definition while preserving the original run as immutable evidence.
Promote workflows through draft, review, staging, production, and rollback states. Each release records graph structure, node configuration, prompt versions, connector scopes, and approval policy.
Constrain execution by environment, connector scope, rate limit, batch size, approval threshold, and maximum affected records so a malformed event cannot become an organization-wide incident.
Material edits capture author, reviewer, diff summary, risk classification, approval evidence, release target, and rollback pointer before production automation changes behavior.
Run locally, in private cloud, in Kubernetes, or through ClearGlass-managed infrastructure with backup, restore, health-check, and rollback procedures aligned to your operational tolerance.
Use single approver, multi-step, role-based, or environment-specific gates for finance, customer communication, security response, infrastructure change, and AI-generated action packages.
CONDUIT treats every connector, credential, workflow, environment, and outbound route as a separate trust decision. The result is automation that can move quickly without inheriting unlimited permission.
Each connector operates as a scoped interface with explicit read, write, export, and side-effect permissions. Sensitive plugins can be isolated by workflow, environment, team, or approval class so one integration cannot silently expand authority across the platform.
Secrets are attached to the narrowest viable workflow context, rotated outside the workflow definition, and withheld from logs, prompts, exported runs, and browser-visible state. Ephemeral credentials can be issued for high-risk actions and revoked without changing the workflow graph.
Deploy workers into segmented networks that match data sensitivity, connector risk, and latency needs. Deny-by-default egress, allowlisted destinations, private service routes, and per-worker network policy reduce exposure when a payload or third-party API behaves unexpectedly.
Evaluate policy at trigger time, before privileged nodes, during approval transitions, and before final side effects. Run-level decisions can consider actor, environment, connector scope, data class, record count, destination, risk score, and workflow version.
Separate retryable steps, terminal failures, manual interventions, and compensating actions. Operators can recover a failed segment without rewriting the full run, duplicating side effects, or erasing the evidence needed for incident review.
Pause durable workflows at approvals, rate limits, dependency outages, scheduled windows, or operator review points. State remains recoverable, timers remain explicit, and stale runs can be expired by policy instead of drifting indefinitely.
Use CONDUIT when automation must be private, reviewable, observable, and recoverable enough to become operating infrastructure.
CONDUIT is 100% free and open source on your own server, forever. When you'd rather not run it yourself, we host it, secure it, and build your first workflows for you.
Choose the operating model that matches your risk posture: community self-hosting for full custody, managed cloud for speed, business support for production teams, or air-gapped enterprise deployment for constrained environments.
Self-hosted at scale, dedicated support, custom integrations, on-prem / air-gapped deployment and procurement-friendly invoicing.
The interface uses purposeful cinematic reveal, kinetic typography, scroll-based dossier progression, glass-layer depth, magnetic hardware-like controls, and reduced-motion fallbacks so the product feels advanced without sacrificing trust or readability.
Ambient grid initializes first, headline deploys word-by-word, copy and operator pills follow in a calibrated sequence, then CTAs become available as command decisions.
Workflow, architecture, governance, integrations, deployment, pricing, and final CTA reveal as secure dossier modules using transform and opacity only.
Buttons, cards, nodes, plan tiers, and integration chips respond with subtle lift, luminous edge scans, and pointer-aware magnetic translation.
Slow orbital light fields and grid drift create infrastructure depth while remaining fixed, low-frequency, and independent of layout.
No layout-thrashing animation: motion stays on transform, opacity, and lightweight filters; observers activate content only near viewport.
prefers-reduced-motion disables ambient drift, shimmer, split text transforms, smooth transitions, and magnetic pointer effects.
Spin up CONDUIT, connect your stack, and let it run — 100% free, 100% open source, 100% yours.