Open source · Apache-2.0 · one Rust binary on NATS
Integration doesn't need an IDE anymore.
Vejas is an integration platform with no builder UI. An agent writes each flow as plain, readable code. A domain expert corrects what it means — a table, a threshold — without touching the code. One Rust binary runs it all, and the whole platform is drivable over MCP.
Vėjas is the old Baltic god of the wind. Wind moves things without anyone drawing the route.
# flow: order_sync
source "vx.shop.orders"
# The shop sends country names; the ERP wants ISO codes.
COUNTRY_CODES = {"France": "FR", "Germany": "DE",
"Italy": "IT", "Portugal": "PT"}
MIN_TOTAL_EUR = 0
ERP_QUEUE = "vx.erp.orders.upsert"
order_ref = split(id, "#")[1]
customer_email = lower(email)
total_eur = num(total_price)
country = COUNTRY_CODES[shipping_address.country]
?? shipping_address.country
# project order lines into ERP positions
positions = []
for line in line_items:
positions = positions + [{sku: line.sku,
qty: num(line.quantity),
unit_eur: round(line.unit_price_cents / 100, 2)}]
end
if total_eur >= MIN_TOTAL_EUR:
emit ERP_QUEUE, {order_ref: order_ref,
customer_email: customer_email, total_eur: total_eur,
country: country, positions: positions}
endBusiness surface
order_sync — as rendered by the panel, from the AST
1 binary · 1 dependency (NATS) · 0 builder UI · nothing proprietary to export
measured: cold start 11–13 ms · 6–8 MB RSS · p50 2 ms, every event hop persisted · cluster promote 60 ms, lossless · the benchmarks
The proof, in 45 seconds
Real SAP, real Salesforce — bridged both ways by two flows an agent wrote.
A domain expert corrects a business rule on screen; the change is shadow-replayed on the real events just processed, promoted, and the next IDoc lives the corrected rule. This recording is also a green end-to-end test — the video can't lie.
The bet
The canvas existed to protect humans from code. That constraint is gone.
Visual designers exist for one reason: developers were expensive, and integration logic is 80% repetitive. So the industry built canvases that let fewer people produce more flows — and locked the logic in proprietary JSON you cannot diff, review, or test without the whole platform running.
In 2026 an agent writes correct glue code for cents. Working flows, not demo snippets: parse this webhook, enrich from that system, handle the retry. Agents don't need protection from code — code is their native interface, and ours too when it comes to review.
Delete the visual designer, and what remains of an integration platform is the runtime, the transport, the connectors, and the observability. That reduced platform is Vejas.
The differentiator
The agent owns how. The human owns what it means.
Agents are better than us at the algorithmic side. They have no idea whether amounts arrive in cents or euros, or what threshold is worth waking someone up for. That knowledge lives in a person's head — so every flow has two surfaces:
The algorithmic body
agent territory
- parsing, pagination, retries, idempotency
- written and rewritten by agents
- reviewed like code, in git
- golden-tested end to end
The business surface
expert territory
- mapping tables, thresholds, constants — literals, extracted from the AST
- rendered in a panel a non-developer can read
- corrected in place, no code touched
- shadow-replayed on real events — before/after diff, then promote or discard
- beyond a literal? say it in plain words — the agent rewrites, the change comes back through the same replay loop
How it carries
Deliberately boring architecture.
Runtime — one Rust binary. Flows run in-process, hot-reload on edit, publish before ack (at-least-once, never a lost emit). The runtime is its own MCP server; a flow declaring tool "…" becomes an MCP tool, one declaring api "VERB /path" becomes an HTTP endpoint with generated OpenAPI.
Transport — NATS with JetStream, the only infrastructure dependency. Two containers, one docker compose up.
Connectors — a typed driver SDK, plus bridges that wrap a program in any language over stdio, isolated by process. That's how SAP ships: native Rust over the official RFC library — BAPIs, IDocs over tRFC, no JVM. Salesforce speaks Bulk API 2.0, streaming. A generic OAuth2 poller stands in for much of a catalog, and an agent writes a new connector from a prompt.
Secrets — secret("path/key") resolves from a vault at run time, fail-closed. Never a literal, so never in git, the panel, or the surface.
Detection — a VPL program under detects/ is a unit too: sequences across sources in event time, run by the Varpulis engine embedded as a library, snapshotted so a half-matched attack survives a kill -9. For correlation next to a SIEM, see Varpulis.
Two screens survive — monitoring for operators, the business panel for experts. Neither can draw a flow.
Running for real
Young, but not a demo.
In production today
Early — two production customers so far — but real: it collects NIS2 supplier-compliance evidence across eight EU countries today. Outbound-only collectors, remote-piloted through a closed command allowlist, secrets unreadable even by the operator.
Microsoft Graph · EDR · leaf-node control plane
SAP ⇄ Salesforce, both ways, streaming
IDocs over transactional RFC on one side, Bulk API 2.0 on the other, wired through two small VejasScript flows a domain expert can read — validated against a real NetWeaver system and a real Salesforce org.
docs/examples/sap-salesforce-bridge
Arguing against myself
Three ways this fails.
Connectors. The value of an iPaaS is its catalog, and catalogs take years. The counter-bet: connector code is exactly what agents produce well, so a small catalog plus a good SDK plus agents might compound faster than catalogs used to. Unproven.
Buyers. Enterprises buy governance and someone to blame. Vejas starts with people who run their own infrastructure and read the code they deploy. Whether it climbs from there is an open question.
Timing. Maybe letting agents write production glue is two years early for most shops. Fine — the demo was cheap and git does not expire.