Most AI workflow builders today are still “chatbot chains.”
Linear.
Provider-locked.
Hardcoded.
Not designed for real multi-agent execution.
I wanted something different:
- graph-native execution
- recursive agent orchestration
- BYOK (Bring Your Own Key)
- multi-provider support
- visual workflows
- Supabase-native backend
- portable JSON runtime
The result is an agent swarm runtime powered by:
- React Flow
- Supabase Edge Functions
- TypeScript
- recursive DAG execution
- provider adapters
The Core Idea
Instead of hardcoding workflows into backend logic, the workflow itself becomes the runtime definition.
Example:
{
"agents": [
{
"id": "ceo",
"provider": "openrouter",
"model": "anthropic/claude-sonnet-4",
"instructionRef": "ceo.md"
}
],
"connections": [
{
"source": "ceo",
"target": "market-agent"
}
]
}
This graph defines:
- execution topology
- agent hierarchy
- orchestration flow
- provider routing
The backend simply executes the graph.
Why Graph-Native Matters
Most “AI agents” are still sequential pipelines:
Prompt A → Prompt B → Prompt C
But real collaborative reasoning looks more like this:
CEO
├── Market Research
├── Competitor Analysis
│ ├── Pricing Worker
│ └── Location Worker
└── Regulation Analysis
This is a DAG (Directed Acyclic Graph).
That means:
- workers can execute in parallel
- parent nodes synthesize child outputs
- workflows become composable
Architecture
React Flow
↓
Workflow JSON
↓
Supabase Edge Function
↓
Graph Compiler
↓
Execution Scheduler
↓
Parallel Node Executors
↓
Provider Router
↓
LLM APIs
BYOK (Bring Your Own Key)
One important decision:
Users own their API keys.
Not us.
That changes everything.
Instead of becoming an inference reseller, the platform becomes:
- orchestration infrastructure
- execution runtime
- agent operating system
Workflow JSON only stores:
{
"credentialId": "openrouter-main"
}
Credentials are encrypted separately.
This allows:
- OpenAI
- Anthropic
- Groq
- Gemini
- Ollama
- OpenRouter
- self-hosted endpoints
all inside the same workflow.
Recursive Execution
The runtime works recursively.
Each node:
- executes children first
- collects outputs
- synthesizes results
- returns upstream
Example:
async function executeNode(nodeId) {
const children = await Promise.all(
node.children.map(executeNode)
)
const output = await llm.generate({
prompt: buildPrompt(children)
})
return output
}
This single pattern unlocks:
- swarm reasoning
- parallel execution
- hierarchical synthesis
Why Supabase Edge Functions?
Because the architecture fits surprisingly well.
We use:
- Edge Functions for execution
- Postgres for workflow persistence
- Realtime for live updates
- RLS for ownership isolation
The result:
- serverless execution
- scalable orchestration
- no dedicated infra initially
Provider Router
Every provider behaves differently.
Some support:
- streaming
- tools
- JSON mode
- reasoning tokens
- vision
So the runtime uses adapters:
interface ProviderAdapter {
generate(input): Promise<Output>
}
Adapters:
- OpenAI
- Anthropic
- Groq
- Gemini
- OpenRouter
- Ollama
The graph runtime doesn’t care which provider executes the node.
Parallelism Is The Superpower
This is where the system starts feeling alive.
These workers can execute simultaneously:
Pricing Worker
Location Worker
Fleet Worker
Market Worker
Then a higher-level agent synthesizes everything into strategy.
Latency drops dramatically compared to sequential chains.
Shared Memory Bus
Agents shouldn’t operate in isolation.
Each node can publish summaries into shared memory:
memory.push({
nodeId,
summary
})
Later agents can retrieve relevant context.
This creates emergent collaboration behavior.
Deterministic DAG vs Planner Mode
Most workflows do NOT need an orchestrator LLM.
For simple graphs:
execute children
then synthesize parent
is enough.
Planner agents are only useful for:
- dynamic routing
- retries
- adaptive decomposition
- auto-spawning agents
This keeps costs low.
What This Actually Becomes
The architecture starts looking less like “AI workflow builder” and more like:
Temporal + Kubernetes + Airflow
for AI agents
Where:
- React Flow = visual programming
- Supabase = orchestration backend
- provider router = universal inference layer
- workflows = portable execution graphs
Biggest Lesson
The moat is probably not:
- prompts
- models
- UI
The moat is:
- portable execution runtime
- graph orchestration
- provider neutrality
- recursive multi-agent execution
The future AI stack may look less like “chat apps”
and more like distributed operating systems for agents.
Building CampShure
We’re building this architecture as part of CampShure — an AI-native platform for graph-based multi-agent workflows, swarm execution, and BYOK orchestration.
If you’re exploring:
- agent infrastructure
- visual orchestration
- recursive AI systems
- workflow runtimes
- AI operating systems
we’d love to connect.
