Helix — Enterprise Agentic AI Platform¶

Deploy intelligent agents that reason, retrieve, and act — with enterprise-grade reliability, security, and observability.

What is Helix?¶

Helix is a Go-native enterprise AI platform that unifies agentic AI, RAG pipelines, multimodal intelligence, and protocol interop — backed by production-grade enterprise integration. Everything is declarative YAML.

Helix is the enterprise AI platform that lets you deploy production-ready AI agents in minutes. Define intelligent agents, RAG pipelines, and multi-agent workflows in declarative YAML — backed by 48 components, 444 connectors, and 60+ orchestration patterns for enterprise integration.

Five AI-first top-level primitives:

agents:       # AI agents with trigger, model, tools, memory, approval
tools:        # Self-describing tools with mandatory input/output schemas
pipelines:    # Data processing flows (RAG, ETL) with source, steps, output
mcps:         # MCP servers that expose agents/pipelines/workflows as tools
workflows:       # Integration routes (event-driven: trigger/steps/target)

Five paradigms, one platform:

• AI Agents — 7 orchestration types + RegisterAgentType for custom ones, 17 LLM providers, tool calling, 8 memory backends, model/memory middleware, durable checkpointing, async tool interrupts, multimodal vision/audio (incl. Qwen-Omni)
• Runtime Governance — Hash-chained tamper-evident audit, scoped kill switches, 4-tier privilege rings, Starlang-predicate policy engine, MCP security scanner, prompt-defense classifier
• RAG & Data Pipelines — 10 data readers, 10 chunking strategies, 10 embedding providers, 10 vector stores, 9 retrieval strategies, 16 postprocessors, 8 synthesis modes
• Protocol Interop — MCP (server + client), A2A (agent-to-agent), AG-UI (streaming chat), A2UI (rich declarative UIs)
• Multimodal Intelligence — Vision, audio, video, and multi-image analysis across OpenAI, Anthropic, Gemini, Ollama, Qwen-Omni
• Enterprise Integration — The backbone: 60+ orchestration patterns, 48 components, 444 connectors across 33 categories, and 17 format conversions via Starlang

Everything is exposed as declarative YAML — no Go code required for most use cases.

Quick Links¶

AI & RAG¶

Protocols & Integration¶

Copilot Development¶

Getting Started¶

Core Framework¶

Production¶

Developer Guides¶

Use Cases & Examples¶

126 production-ready YAML examples across 22 sections — full guide.

At a Glance¶

AI Agents¶

• 7 built-in agent types — ReAct, Supervisor, Plan-Execute, Deep, Sequential, Parallel, Loop — plus RegisterAgentType for custom orchestration patterns
• 17 LLM providers — OpenAI, Anthropic, Ollama, Qwen (DashScope), Groq, Mistral, Azure, Bedrock, Vertex (alias: Gemini), Cohere, Together, Fireworks, DeepInfra, xAI, HuggingFace, Replicate, vLLM
• Reasoning & audio I/O — reasoning_effort (o1/o3/gpt-5), reasoning_content (Qwen3 / DeepSeek-R1), audio in/out (Qwen-Omni, GPT-4o-audio), Message.FinishReason across every provider
• 8 memory backends — Conversation, Sliding Window, Summary, Token Window, Long-Term, SQL, Vector, Composite — wrappable with named memory_middleware
• 5 agent flows — Sequential, Parallel (with fail_fast / collect error policy), Conditional, Loop, Pipeline
• Tool calling — Function tools, streaming tools, multimodal tools, async tool.Interrupt for human-in-the-loop with durable CheckpointStore
• Unified event stream — OnEvent projection covering model_request / model_response / tool_call / tool_result / approval / guardrail / governance_block / interrupt / context_overflow_retry / …

Runtime Governance¶

• Hash-chained tamper-evident audit log — Verify integrity of every allow/deny/kill decision after the fact; bridgeable to engine.AuditStore so /api/audit serves a unified view
• Scoped kill switches — Global / Agent / Capability scopes flipped at runtime via /api/kill-switch; pluggable RedisKillSwitchBackend propagates state cluster-wide via pub/sub
• 4-tier privilege rings — Admin / Standard / Restricted / Sandboxed, default-deny
• Policy engine with Starlang predicates — Declarative allow / deny / review / rate_limit rules with first-match-wins and conflict-resolution strategies; RedisRateLimitBackend for cluster-wide max_calls / window caps
• Three native seams — Agent dispatcher gate, engine.Interceptor adapter for workflow-level gating, and governance://stack-name?action=X URI component for inline pipeline steps
• MCP security scanner — Typosquatting (Levenshtein-1 + Unicode confusables), tool poisoning, hidden instructions, rug-pull detection
• Prompt-defense classifier — Instruction override, prompt exfiltration, credential leak, approval bypass

RAG Pipeline¶

• 10+ data readers — Text, JSON, PDF, HTML, CSV, Markdown, XML, DOCX, Starlang, Directory (auto-detect) + Image, Audio, and OCR readers
• 10 chunking strategies — Fixed, Token, Sentence, Recursive, Semantic (embedding-based), Code (5 languages), Markdown, HTML, Sliding Window, Hierarchical
• 10 embedding providers — OpenAI, Ollama, Mistral, Vertex/Gemini, Bedrock, Jina, HuggingFace, Nomic, Cohere, Voyage + CLIP multimodal embeddings
• 10 vector stores — Milvus, Pinecone, Qdrant, Elasticsearch, Weaviate, pgvector, Redis, ChromaDB, OpenSearch, In-Memory
• 13 retrieval strategies — Simple, BM25, Fusion, Hybrid, MMR, Ensemble, Auto-Merging, Router, Parent + HyDE, MultiQuery, StepBack, SubQuestion
• 8 OCR backends — Docling, MinerU, Marker, Tesseract, Surya, Unstructured.io, Azure Document Intelligence, Vision LLM
• 16 postprocessors — Cohere/Jina rerankers, similarity filters, metadata filters, PII masking, diversity, recency, long-context reorder, and more
• 8 synthesis modes — Compact, Refine, Tree Summarize, Simple Summarize, Accumulate, Compact-Refine, Context-Only, Generation-Only
• Evaluation — Faithfulness, answer relevancy, context relevancy, hit rate, MRR, NDCG, MAP
• Knowledge graph RAG — Entity extraction, graph building, multi-hop traversal

Multimodal Intelligence¶

• Multimodal — Vision (image analysis), audio input/output, video, multi-image comparison across OpenAI, Anthropic, Gemini, Ollama, Qwen-Omni

Tools¶

• tools: primitive — Self-describing tools with mandatory input and output schemas, auto-generates tool:// URIs, validated input, auto-discoverable by MCP

Protocols¶

• MCP server + client — Expose workflows as MCP tools, call external MCP servers
• A2A server + client — Google's Agent-to-Agent protocol with Agent Card discovery
• AG-UI server — CopilotKit's streaming protocol for chat frontends (SSE)
• A2UI server — Google's declarative UI protocol for rich agent surfaces

Enterprise Integration¶

• 48 components — HTTP, Kafka, Redis, PostgreSQL, MongoDB, NATS, AMQP, gRPC, S3, Elasticsearch, Docker, WebSocket, FTP, SMTP, Slack, Cron, and 17 LLM providers
• 444 connectors — across 33 categories: AI, AWS, Azure, Google, Kubernetes, databases, messaging, monitoring, file systems, and more
• 60+ orchestration patterns — Content-Based Router, Splitter, Aggregator, Circuit Breaker, Saga, Resequencer, Load Balancer, Scatter-Gather, Dead Letter Channel, Idempotent Consumer, and many more
• Full YAML DSL — every pattern, every component, every step configurable via declarative YAML

Production¶

• Security — Declarative per-workflow auth (JWT, OAuth2, Basic Auth, API Key), TLS, rate limiting, IP allowlists, secret resolution (env, Vault, AWS Secrets Manager)
• Observability — Prometheus metrics, OpenTelemetry tracing, SLA percentile monitoring (p50/p95/p99), Grafana dashboards
• Resilience — Circuit breaker, retry, timeout, throttle, dead letter channel, SEDA backpressure (fail/block/drop/newest)
• Clustering — Gossip-based membership, leader election, distributed locks, singleton workflow gating (Redis backend)
• Large file streaming — StreamBody abstraction for constant-memory processing of multi-gigabyte files, S3 multipart upload, streaming HTTP, streaming JSON array processing
• Enterprise — Graceful shutdown with drain timeout, audit logging (ring buffer + slog), multi-tenancy (header-based, allowlists), hot reload
• Zero external deps for core — Components bring their own drivers; core engine is stdlib-only

Examples¶

Multi-Agent Supervisor¶

agents:
  - id: research-team
    type: supervisor
    trigger: http-server://0.0.0.0:8080/api/research
    model:
      provider: anthropic
      model: claude-sonnet-4-20250514
    system_prompt: "You coordinate a research team."
    sub_agents:
      - id: researcher
        type: react
        model:
          provider: groq
          model: llama-3.3-70b-versatile
        system_prompt: "You research topics thoroughly."
      - id: writer
        type: react
        model:
          provider: openai
          model: gpt-4o
        system_prompt: "You write clear, concise reports."

RAG Pipeline¶

workflows:
  - id: rag-qa
    trigger:
      uri: http-server://0.0.0.0:8080/api/ask
    steps:
      - rag-ingest:
          reader: directory
          recursive: true
      - rag-chunk:
          strategy: semantic
          threshold: 0.5
      - rag-embed:
          provider: jina
          model: jina-embeddings-v3
      - rag-store:
          store: pgvector
          connection: "postgres://user:pass@db:5432/rag"
      - rag-retrieve:
          strategy: hybrid
          top_k: 10
      - rag-postprocess:
          steps:
            - type: cohere-rerank
              params:
                api_key: "${env:COHERE_API_KEY}"
                top_n: "5"
      - rag-synthesize:
          mode: compact
          model:
            provider: groq
            model: llama-3.3-70b-versatile

AI Chat API¶

agents:
  - id: ai-chat
    type: react
    trigger: http-server://0.0.0.0:8080/api/chat
    model:
      provider: openai
      model: gpt-4o
    system_prompt: "You are a helpful support agent."
    tools:
      - name: search_docs
        type: function
        description: "Search the knowledge base"

Vision Agent¶

agents:
  - id: image-analyzer
    type: react
    trigger: http-server://0.0.0.0:8080/api/analyze-image
    model:
      provider: openai
      model: gpt-4o
    system_prompt: "Analyze images and describe what you see in detail."

Content-Based Routing with Kafka¶

workflows:
  - id: order-router
    trigger:
      uri: kafka://orders?brokers=localhost:9092&group=helix
    steps:
      - choice:
          when:
            - starlang: 'read(payload, "application/json")["priority"] == "high"'
              steps:
                - target: kafka://high-priority-orders?brokers=localhost:9092
            - starlang: 'read(payload, "application/json")["priority"] == "low"'
              steps:
                - target: kafka://low-priority-orders?brokers=localhost:9092
          otherwise:
            steps:
              - target: kafka://default-orders?brokers=localhost:9092

Run It¶

helix run flow.yaml

What Makes Helix Different¶

Helix is an AI Agent Orchestration Platform with enterprise integration built in — not the other way around.

• Agents natively connect to Kafka, PostgreSQL, Redis, S3, and 444+ connectors
• Full MCP/A2A/AG-UI/A2UI protocol support with session persistence
• 7 agent types with human-in-the-loop, guardrails, cost tracking, evaluation
• Starlang expression language with AI modules (vectors, text, schema)
• tools: primitive with mandatory input+output schemas, auto-discoverable by MCP

The killer feature: An AI agent that IS the integration — not an integration that calls an AI agent.

workflows:
  - id: order-processor
    description: "AI agent that processes orders from Kafka"
    input-schema:
      type: object
      properties:
        order_id: { type: string }
        items: { type: array }
        customer_email: { type: string }
      required: [order_id]
    trigger:
      uri: kafka://orders?brokers=kafka:9092&group=helix
    steps:
      - agent:
          id: order-agent
          type: react
          model:
            provider: anthropic
            model: claude-sonnet-4-20250514
          system_prompt: |
            You process customer orders. Check inventory, validate the order,
            and route to fulfillment. Flag suspicious orders for human review.
          approval_policy: tagged
          approval_tools: [charge-payment]
          tools:
            - name: check-inventory
              type: function
              description: "Check product availability"
            - name: charge-payment
              type: function
              description: "Charge customer (REQUIRES APPROVAL)"
      - target: kafka://processed-orders?brokers=kafka:9092

mcps:
  - id: order-tools
    addr: "0.0.0.0:3100"
    expose: [order-processor]

helix:
  session:
    enabled: true
    store: redis
    redis_addr: redis:6379

Project Stats¶