Workflows

Real programming. Zero code.

Build, version, and ship complex automation visually. Every workflow compiles to a typed, schema-checked graph that runs across your worker fleet — with first-class control flow, edge transforms, and strict data contracts.

Visual Editor

Drag-and-drop SVG canvas with a node toolbox and a flyout config panel. Layout lives inside the workflow definition — no sidecar files, no drift between editor and runtime.

Edge CEL Editing

Every edge between nodes can carry a CEL expression that transforms, filters, or reshapes data in transit. Type-checked against field schemas at compile time, with a built-in snippet library.

Control Nodes

Sequential, Parallel, Loop, Condition, Switch, Batch, and Split — real control flow primitives with worker pinning, iteration safety limits, CEL exit checks, and configurable output modes.

Strong Schema Management

JSON-schema-based field definitions with typed fields — string, number, boolean, file, url, email, date, json. Required flags, list fields, and schemas that are reusable across every trigger and agent node.

Data Sources & Sinks

First-class source and sink nodes for BigQuery, PostgreSQL, and MySQL. Credentials live in an encrypted vault and integrations declare whether they provide reads, writes, or both — so the editor only shows you legal wiring.

edge · cel transform TYPE-CHECKED
// Runs on the edge between Validate → Enrich.
// Compiled once, executed per message.
{
  "user_id":  input.customer.id,
  "amount":   input.order.total * 1.08,
  "region":   input.customer.address.country,
  "tags":     input.order.items.map(i, i.sku),
  "priority": input.order.total > 1000 ? "high" : "normal"
}
Workers

Your hardware.
Your data. Your rules.

A Nanomite worker is a single binary that turns any machine into an execution node on the grid — from the laptop in your backpack to the rack in your datacenter. Nothing phones home except the worker itself.

On your laptop

Run workflows locally during development with the same binary you ship to production. No special mode, no emulator — your laptop is just another worker on the grid.

On hardware you own

Drop workers on the servers that already sit next to your data. No network egress, no cloud data tax, no surprise bills from a vendor moving bytes across regions.

At the edge

Ship workers to edge devices near the sensors, cameras, and machines that generate your events. Process where the data lives — send only decisions back to the control plane.

In your cloud

Spin up GPU-backed workers in your own cloud accounts. Nanomite never touches your VPC — it just speaks gRPC to whoever dials in. Your account, your IAM, your bill.

What every worker brings to the grid

  • Hardware introspection
    CPU, cores, architecture, RAM, disks, GPUs & CUDA version.
  • Label-based affinity
    Route nodes to specific machines by tag. Pin loops. Keep GPU work on GPU hosts.
  • Streaming task dispatch
    Long-lived gRPC stream. No polling. No webhooks hammering.
  • Cross-platform
    Linux & macOS. amd64 & arm64. One binary, no runtime.
  • Live fleet view
    Search, sort, and drill into any machine from the control plane in real time.
  • One env var to connect
    Drop in an auth token, start the binary, done. Zero configuration files.
Agents, Skills & MCPs

Compose intelligence,
don't hardcode it.

Agents are first-class citizens in Nanomite — multi-provider, multi-modal, and composable. Package expertise as skills, plug in external tools via MCP servers, and wire them into workflows with typed inputs and outputs.

Agents

Multi-provider out of the box — Anthropic, OpenAI, Google, xAI, and local LLMs via Ollama and vLLM. Chat or tool-style. Swap providers mid-conversation without losing context.

Skills

Package domain knowledge as reusable, markdown-based skills. Inject expertise into any agent without copy-pasting prompts. Version skills like code.

MCP Servers

Plug in any Model Context Protocol server — streamable HTTP, SSE, or local stdio. Auth headers stay in the vault. Cached tool discovery with JSON Schema validation.

Built for real orchestration

  • Typed inputs and outputs. Agent nodes bind to field schemas, so results flow cleanly through the graph.
  • Structured output. Constrain the model to a JSON Schema for reliable downstream parsing.
  • Built-in system tools. Exec, file I/O, web search, HTTP — batteries included, toggled per agent.
  • Prompt injection scanning. Tool outputs and MCP responses are scanned before they reach the model.
  • Session state & memory. Persistent conversation state lives in the control plane, not baked into prompts.
Integrations

Plug in to anything
that speaks data.

Nanomite ships with a growing catalog of integrations — unified source and sink semantics, credentials in an encrypted vault, and editor affordances that only let you wire what actually works.

Available Now
BQ
BigQuery
Source · Sink

Service Account or Workload Identity auth. Storage Write API sink, managed writer.

PG
PostgreSQL
Source · Sink

Host, port, SSL mode, schema lock. Source tooling for agents, batch INSERT sink.

MY
MySQL
Source · Sink

TLS mode, database lock, schema discovery. Source tooling for agents, batch INSERT sink.

On the Roadmap

SRT — Secure Reliable Transport

Flagship

Low-latency video stream ingestion straight into workflows. Pair with on-prem ML models for real-time video intelligence: camera tracking, signal analysis, object detection, and live event decisioning — all processed on workers next to the cameras.

live video sub-second latency on-prem ml camera fleets
AWS
Amazon Kinesis
Roadmap

Stream ingestion at AWS scale. Bind shards to workers, process records in flight.

GCP
Google Cloud Pub/Sub
Roadmap

Managed messaging with push and pull semantics. At-least-once delivery into workflows.

KF
Apache Kafka
Roadmap

The event streaming backbone. Consumer groups, exactly-once, compacted topics.

TW
Twilio
Roadmap

SMS, voice, and WhatsApp as both triggers and actions. Conversational automation at scale.

RQ
RabbitMQ
Roadmap

Classic AMQP messaging with queues, exchanges, and routing keys — on your own broker.

+
…and more
Planned

Snowflake, Databricks, Redis Streams, NATS, MQTT, S3 event notifications. Tell us what you need.

Need something that isn't on the list?

Request an Integration

See how it all fits together.

Workflows, workers, agents, and integrations are one platform — all designed to run on infrastructure you own.