Code AI workflows fast.
Run production AI without compromises.

All nodes run in Go, with Go and Rust streaming workers on Kubernetes. Client and user isolation is built in. Per-user memory stays persistent. Workflows can mutate live when performance shifts. Each node autoscales in isolation. From first workflow to enterprise load, one runtime.

contact@ionun.com See how it works

400+ integrations

E2EE by default

Per-node autoscaling

Multi-tenant isolation

Built different. By design.

Every feature is a structural advantage. Not a checkbox.

Mermaid DSL

Define entire AI pipelines in human-readable syntax. LLM-native, trivially mutable. An AI can generate, modify, and reason about workflows as easily as reading a sentence.

B{{Agent:ProcessText}} *model=@best*

Per-node Kubernetes scaling

Your 2ms transform and 5-second LLM inference do not share the same scaling policy. Each node gets its own HPA, its own resource profile. 1 pod for transforms. 8 for inference bursts.

Node A: 1 replica -> Node B: 8 replicas

Zero-knowledge encryption

ChaCha20-Poly1305 AEAD with one flag. The encryption key is never stored by ionun and is provided externally at runtime. Even if storage is compromised, user data stays unreadable.

D((Notify:result)) *e2ee=auto*

Per-user persistent memory

Every user gets dedicated fast memory: isolated, hot-cached, encrypted at rest. Workflows remember conversation history, preferences, accumulated context across sessions.

Redis-backed · zero-knowledge · auto-tiered

Adaptive workflows

When a node underperforms (2x latency, rising error rate), ionun can branch, swap, alert, or predict. Autonomous orchestration: workflows that heal and optimize themselves.

model=@best -> auto-failover on degradation

Native security DSL

Credentials injected from secret stores at runtime. Multi-tenant isolation at the database level. Client auth via API key + short-lived JWT. Security in the syntax, not as an afterthought.

e2ee=auto · secret_store=vault · jwt=true

How it works

Write workflows in Mermaid.

No drag-and-drop builder. No JSON walls. Just syntax that humans and LLMs understand natively.

analysis-pipeline.mermaid 6 lines · 2 agents

flowchart TD
    A{SSE:ANALYSIS_STARTED} *data=$analysisId* --> B
    B(Transform:AssembleText) --> C
    C{{Agent:ProcessText}} *model=claude-4.6 timeout=3m input=$text* --> D
    D[(Fetch:GetUserData)] --> E
    E{{Agent:MatchResults}} *model=@best input=$C.result,$D.data* --> F
    F{SSE:ANALYSIS_COMPLETED}

This pipeline

Emits a real-time SSE event
Assembles input data
Runs an AI agent on the text
Fetches user data from your backend
Runs a second AI agent cross-referencing both outputs
Signals completion via SSE

6 lines. Two AI agents. Real-time streaming. Cross-node data flow.

Node metadata

B{{Agent:ProcessText}} *model=claude-4.6 timeout=3m input=$assembled_text*

Key What it does

model=claude-4.6 Explicit model selection

model=@best ionun picks the optimal model in real-time

model=@fastest Optimize for latency

timeout=3m Execution time limit

input=$text Pull from workflow context

input=$C.result Reference another node's output

e2ee=auto ChaCha20-Poly1305 end-to-end encryption

streaming=true Enable streaming output

Per-user memory

AI products need memory,
not just execution.

ionun gives every user their own persistent memory: fast, isolated, hot-cached, and encrypted at rest. The encryption key is never stored by ionun.

When your user comes back tomorrow, ionun already knows them. This turns a stateless pipeline runner into a runtime for intelligent products.

Isolated per client Each product has its own namespace
Per-user fast state Hot Redis-backed memory per user
Encrypted at rest Key never stored by ionun
Zero-knowledge Key provided externally at runtime
Auto-tiered Hot to cold storage automatically
Context-aware History, preferences, accumulated data

ionun Memory Layer

Client A

User 1

Memory fast · encrypted

Client B

User 1

Memory fast · enc.

User 2

Memory fast · enc.

Redis (hot)

auto-tier

Cold storage

Zero-knowledge · Key never stored by ionun

Per-Node Independent Scaling

Node A

light

1 replica

Standard HPA

Node B

CPU-heavy

8 replicas

Burst HPA

Node C

GPU inference

4 replicas

GPU-aware HPA

Per-node scaling

Scaling that matches reality.

Your AI pipeline has a 2ms data transform and a 5-second LLM inference in the same workflow. They do not need the same resources. They should not share the same scaling policy.

ionun scales each node independently on Kubernetes with separate replicas, separate HPAs, separate resource profiles. No other orchestration engine does this.

Independent HPAs Each node type has its own autoscaling policy

Resource isolation CPU, memory, GPU profiles per node

Burst scaling Inference nodes burst on demand, independently

400+ nodes. 60+ categories.

Everything you need, ready to wire into any workflow.

OpenAIAnthropicGroqMistralOllamaHuggingFace

LangChain

ChainsAgentsMemoryRetrieversTools

VectorStore

PineconeQdrantWeaviateChromaMilvus

Database

PostgreSQLMySQLMongoDBSupabaseRedis

Communication

SlackDiscordTelegramWhatsAppEmail

Storage

S3GCSAzure BlobDropboxDrive

DevOps

GitHubGitLabJenkinsJiraKubernetes

Security

OAuthJWTHMACEncryptionKey Mgmt

Finance

StripePayPalWiseAccounting

CRM

HubSpotSalesforcePipedriveActiveCampaign

Marketing

MailchimpSendGridActiveCampaign

Monitoring

DatadogPagerDutyGrafanaPrometheus

+ 48 more categories including Analytics, IoT, Healthcare, Legal, HR, and more

Architecture

Enterprise AI Infrastructure

7 microservices. Go backend. Svelte dashboard. PostgreSQL. Redis. Kubernetes.

Clients SDK / API

↓

Gateway REST · SSE · WebSocket · Auth · E2EE

↓

ionun Core History · Matcher · Mermaid Parser

PostgreSQL

↓

Workers

Go · AI Go · Data Rust · Optim

enterprise-agent-pipeline.mermaid

flowchart TD
    A[(Fetch:UserContext)] *input=$userId* --> B
    B{{Agent:Understand}} *model=@fastest input=$A.context,$message* --> C
    C{Switch:intent} *mode=rules*
    C --> |query| D{{Agent:Retrieve}} *model=claude-4.6*
    C --> |action| E{{Agent:Execute}} *model=@best*
    C --> |memory| F(Transform:UpdateMemory)
    D --> G((Return:response))
    E --> G
    F --> G

What this gives enterprises

- Full agent orchestration: multi-step reasoning, tool use, memory management

- Per-user memory: each user has isolated persistent context across sessions

- Multi-model routing: @fastest for quick queries, @best for complex tasks

- Automatic failover: if a model provider degrades, traffic shifts in real time

- Cost control: Rust workers optimize data before inference, cutting token spend

- Compliance: E2EE on every payload, multi-tenant isolation, audit trail via event sourcing

One platform to run your entire AI agent infrastructure. Not five tools duct-taped together.

Roadmap

Planned for MVP May 2026

Production-grade orchestration engine
Workflow DSL parser and executor
400+ integrations across 60+ categories
Secure gateway with client auth and encryption
Monitoring dashboard
Multi-tenant isolation

Code AI workflows fast. Run production AI without compromises.