Orchestration Platforms: Agent Context vs Data Pipelines vs Integration Workflows

TLDR: arizuko orchestrates agent context (message routing, memory scoping, multi-agent coordination), not data pipelines or integration workflows. Where Dagster routes data assets and Temporal guarantees durable execution, arizuko routes agent sessions and isolates context per team. The platform sits above agent frameworks (Claude Code, LangGraph) and below messaging platforms (Slack, Telegram), providing the routing table and control plane for multi-tenant agent deployments. Self-hosted by default, everything stays on your box.

Platform Comparison

Agent Context arizuko

What it orchestrates:

Agent sessions — message routing, memory scoping, topic forking, multi-agent coordination. Routes messages to folders, isolates context per team, composes tools via MCP.

Orthogonal contribution:

Multi-tenant agent context orchestration primitives: topic-suffix routing (target=corp/eng#alerts), folder-per-team isolation (container boundaries), sibling observation (context sharing without secret leakage), session forking (cp -r .claude/).

When to use:
  • Deploying Claude agents across multiple teams with isolated memory/secrets
  • Routing messages from Slack/Telegram/Discord to specific agent folders
  • Multi-agent coordination with shared context but scoped permissions
  • Self-hosted requirement (no metadata leaves your infrastructure)
When NOT to use:
  • You need workflow execution guarantees → use Temporal
  • You're orchestrating data pipelines → use Dagster
  • You need app-to-app integration automation → use n8n
  • You want managed SaaS with zero ops → arizuko is self-hosted only

Agent Context Pentagon

What it orchestrates:

Multi-agent teams with spatial canvas UI. Visual workspace where agents have status, communicate directly, and coordinate across repos. Desktop-based agent coordination.

Orthogonal contribution:

Spatial canvas for agent visualization and coordination. See your whole team at a glance: who's active, who's waiting, who's idle. Agent-to-agent communication (DMs, group channels, structured handoffs) with visual feedback.

When to use:
  • Local development with multiple AI employees (engineering, ops, research teams)
  • Visual debugging of multi-agent workflows
  • Coordination across repositories (each agent gets own clone)
  • Real-time status monitoring without dashboards
When NOT to use:
  • Production multi-tenant deployment → use arizuko
  • Message routing from external platforms (Slack, Telegram) → use arizuko
  • Team-based isolation with container boundaries → use arizuko

Data Pipeline Temporal

What it orchestrates:

Distributed workflows with durable execution. Guarantees workflows complete despite infrastructure failures, persists state at each step, resumes from last checkpoint on different worker.

Orthogonal contribution:

Durable execution with replay guarantees. Replaces manual retry logic + state tracking DB + cron scheduler. Event sourcing for crash recovery, structured retry policies, automatic timeouts.

When to use:
  • Payment processing, saga patterns, multi-step transactions
  • Microservice coordination with guaranteed completion
  • Long-running workflows (hours/days) that must survive restarts
  • Worker versioning required (2026 enhancement)
When NOT to use:
  • Simple cron jobs without complex state → use systemd timers
  • Real-time event processing (millisecond latency) → use Kafka
  • Data pipeline orchestration with asset lineage → use Dagster

Data Pipeline Dagster

What it orchestrates:

Data pipelines — tables, datasets, ML models, reports. Asset-first orchestration where data assets are first-class citizens with clear lineage and dependencies.

Orthogonal contribution:

Asset-first orchestration (not task-first). Unified control plane for data platforms with integrated observability. Multi-tenancy via code locations (subprocess + virtualenv isolation).

When to use:
  • Data engineering teams building data platforms in code
  • Asset lineage tracking (which tables depend on which models)
  • Multi-tenant data pipeline deployment
  • Integration with dbt, Spark, Pandas, Polars
When NOT to use:
  • Python-first dynamic workflows → use Prefect
  • Battle-tested batch ETL at massive scale → use Airflow
  • General distributed execution guarantees → use Temporal

Data Pipeline Prefect

What it orchestrates:

Python workflows with flexible execution. Task-based model (not asset-first). Runs your Python functions as-is in your infrastructure — add @flow decorator and done.

Orthogonal contribution:

Python-first orchestration with zero marginal cost (charges by users/workspaces, not task executions). Dynamic, event-driven workflows. Operational resilience without opinionated data model.

When to use:
  • Python-first teams who want flexibility over opinionated best practices
  • Dynamic workflows where structure changes at runtime
  • Cost-sensitive deployments (no per-execution charges)
  • Event-driven automation (not just scheduled)
When NOT to use:
  • You want asset lineage and data-first orchestration → use Dagster
  • You need durable execution guarantees → use Temporal
  • Legacy Airflow replacement at enterprise scale → use Airflow (or Astronomer)

Data Pipeline Apache Airflow

What it orchestrates:

Batch data processing — ETL/ELT, data integration, ML training workflows. Battle-tested at scale with well-defined start and end. DAG-based orchestration.

Orthogonal contribution:

Battle-tested batch orchestration at massive scale. Largest ecosystem for data integrations. Regulatory compliance in financial services (Dodd-Frank, GDPR reporting).

When to use:
  • ETL/ELT at enterprise scale (100s of pipelines)
  • Financial services regulatory reporting
  • ML model training with SageMaker integration
  • Existing Airflow investment or expertise
When NOT to use:
  • Real-time streaming (sub-second latency) → use Kafka
  • Thousands of tiny tasks every few seconds → doesn't scale
  • Modern data platform with asset lineage → use Dagster
  • Python-first flexibility → use Prefect

Integration n8n

What it orchestrates:

Integration workflows — app-to-app automation, API calls, webhooks, form submissions. Node-based canvas with 70+ AI-specific nodes (LLMs, embeddings, vector DBs, OCR).

Orthogonal contribution:

Self-hosted AI-native automation platform. Charges per workflow execution (not per task), dramatically cheaper for complex multi-step automations. LangChain integration with 70 AI nodes.

When to use:
  • Self-hosted requirement (no data leaves your infrastructure)
  • AI-native workflows (LLM chains, embeddings, vector search)
  • Complex automations with loops, branching, parallel execution
  • Technical teams comfortable with node-based canvas + JSON
When NOT to use:
  • Non-technical teams → use Zapier
  • Need 7,000+ integrations out-of-box → use Zapier
  • UI-triggered automation for internal tools → use Retool Workflows

Integration Zapier

What it orchestrates:

Personal productivity automation — 7,000+ integrations, no-code. Connects applications at surface level (form submission → email, Slack → Notion). Charges per task.

Orthogonal contribution:

Largest integration breadth (7,000+ apps). No-code accessibility for non-technical teams. AI Agents (autonomous AI teammates) and Copilot (AI-powered builder) in 2026.

When to use:
  • Non-technical teams (marketing, sales, ops)
  • Simple 2-3 step automations between common apps
  • Time-to-automation more important than cost at scale
  • Zapier Agents for autonomous workflows (2026 feature)
When NOT to use:
  • Enterprise governance required (95%+ reliability, audit trails) → use Workato
  • Self-hosted requirement → use n8n
  • Complex automations with loops/branching → use n8n
  • Cost-sensitive at scale (charges per task) → use n8n or Prefect

Integration Retool Workflows

What it orchestrates:

UI-triggered automation for internal tools. Extension of Retool's internal tool builder, not standalone automation engine. Background tasks tied to user interfaces.

Orthogonal contribution:

Tight integration between UI components and workflow engine. Natural extension for teams already standardized on Retool for admin panels, ops dashboards, approval flows.

When to use:
  • Already invested in Retool ecosystem
  • Automation surfaces inside internal apps (approval button triggers workflow)
  • Consolidated stack preferred (one platform for UI + automation)
When NOT to use:
  • Standalone automation platform → use n8n or Prefect
  • AI-native workflows → use n8n
  • Not using Retool for internal tools → limited value outside ecosystem

Memory Letta (MemGPT)

What it orchestrates:

Agent memory architecture — tiered memory (core/archival/recall). OS-inspired model: core memory (always in-context, like RAM), archival memory (vector store queried explicitly), recall memory (conversation history).

Orthogonal contribution:

Tiered memory architecture for stateful agents. Agents learn and self-improve over time. #1 model-agnostic OSS harness on TerminalBench. Conversations API for shared memory across parallel experiences (Jan 2026).

When to use:
  • Long-running agents that persist across sessions
  • Agents that continuously learn from experience
  • Memory-first coding agents (Letta Code)
  • Self-hosted memory (UC Berkeley open-source)
When NOT to use:
  • Short-lived agents with no learning requirement
  • Cross-tool organizational memory → use Memory Store
  • Agent session orchestration (routing/isolation) → use arizuko

Memory Memory Store

What it orchestrates:

Organizational memory aggregation — cross-tool context syncing (Fathom meetings, Slack, Granola notes, Claude/Codex outputs). Background organization by project/person/decision. MCP-native distribution.

Orthogonal contribution:

Shared context layer (not internal memory architecture). Multi-source capture, background organization, shared recall across agents + humans. Memory portable across model/client boundaries via MCP.

When to use:
  • Team organizational memory (1-12 users)
  • Cross-tool context aggregation (record in Claude, recall in Codex)
  • Fragmented documentation problem (no single source of truth)
  • Living playbooks accessible in AI tools
When NOT to use:
  • Self-hosted requirement → Memory Store is YC SaaS product
  • Single-agent focus → use Letta for agent-internal memory
  • Local-only memory → use Letta or agent framework's native memory

Orthogonal Contributions Table

Platform Domain Orthogonal Contribution What It Replaces
Temporal Distributed execution Durable workflows with replay guarantees Queues + state DB + cron + manual retry logic
Dagster Data pipelines Asset-first orchestration with lineage Task-first schedulers + scattered metadata
Prefect Python workflows Flexible execution in your infra Airflow complexity + vendor lock-in
Airflow Batch data processing Battle-tested ETL at scale Custom cron jobs + dependency management
n8n Integration automation Self-hosted AI-native workflows Zapier SaaS + privacy concerns
Zapier Personal automation 7,000+ integrations, no-code Manual data entry + copy-paste between apps
Retool Workflows UI-triggered automation Tight UI integration for internal tools N/A (only for Retool users)
arizuko Agent context Multi-tenant routing + isolation Manual agent deployment + context leakage
Pentagon Multi-agent teams Spatial canvas with agent communication Terminal windows + manual coordination
Letta Agent memory Tiered memory (core/archival/recall) Flat vector stores + no learning over time
Memory Store Organizational memory Cross-tool aggregation + MCP distribution Fragmented docs + siloed tool contexts

Why Julep Failed: The Repackaging Trap

Cautionary Tale: No Orthogonal Value

Shutdown date: December 31, 2025

Architecture: FastAPI + Temporal + PostgreSQL + TimescaleDB + TypeSpec

Promise: "Serverless platform for AI workflows and agents"

What they built:

The fatal flaw: Julep wrapped Temporal + PostgreSQL with no novel primitive. When asked "what does Julep do that Temporal doesn't?", the answer was ceremony:

Oracle test failure: "Why use Julep vs Temporal + Supabase?" → No answer beyond "we wrote docs."

Lesson: Ceremony is not orthogonality. Users could build Julep's functionality with Temporal + Supabase in 3 days. Hosted service couldn't justify pricing when self-hosting the underlying primitives was trivial.

Pivot: Team launched memory.store (YC P26) — cross-tool aggregation with MCP distribution. Actually orthogonal.

Bring Your Own Agent to arizuko

arizuko as Routing Layer + Control Plane

arizuko doesn't compete with agent frameworks — it orchestrates them. Same relationship as Dagster (control plane) + dbt (execution engine) in data pipelines.

What you bring:

What arizuko provides:

Architecture stack:

Messaging Platforms (Slack, Telegram, Discord, WhatsApp)
           ↓
    [arizuko routing + isolation]
           ↓
Agent Frameworks (Claude Code, LangGraph, Temporal, Julep)
           ↓
    Execution (LLM calls, tool use)

Analogy: Kubernetes orchestrates containers. arizuko orchestrates agent sessions.

Control Plane Architecture Comparison

Platform Control Plane Execution Metadata Storage Data Residency
Dagster+ Managed SaaS Customer-hosted agents Dagster-hosted DB Metadata leaves env
Prefect Cloud Managed SaaS Customer infra Prefect-hosted Metadata leaves env
Zapier Managed SaaS Zapier-hosted Zapier-hosted All data leaves env
n8n Cloud Managed SaaS n8n-hosted n8n-hosted All data leaves env
Temporal Cloud Managed SaaS Customer workers Temporal-hosted History leaves env
Airflow (Astronomer) Managed SaaS Customer-hosted Astronomer-hosted DAG defs leave env
Retool Cloud Managed SaaS Retool-hosted Retool-hosted All data leaves env
arizuko Self-hosted Self-hosted containers Local SQLite Nothing leaves box
Letta Self-hosted Local agents Local vector DB Nothing leaves box
Pentagon Local desktop Local agents Local filesystem Nothing leaves box

Sources

Existing Research:

Web Research (2026-05-20):