01
Code ownership
Build visually, then keep the code path open. Saved graphs generate LangGraph.js TypeScript project files instead of staying trapped as opaque workflow JSON.
UtopikAI
Agent systems workbench
Main agent. Visual graphs. Container-backed execution.
Build agents like systems,not prompt piles.
UtopikAI is a web workbench for composing LangGraph agent systems visually, running them with observable state, connecting tools through MCP, and keeping the generated TypeScript path open.
Design commitments
A builder for teams that have to operate what they create.
The product is intentionally not a bubblegum no-code canvas or a mystical AI oracle. It is a readable machine for composing, running, publishing, and improving agent systems.
02
True boundaries
Each user gets container-backed execution and skills workspace boundaries. Workspace policy and sandbox checks reinforce that tenant boundary instead of pretending to replace it.
03
Operational legibility
Runs, steps, checkpoints, tool access, memory context, and reviewer artifacts stay visible enough for teams that need to debug systems after launch.
Operating model
One agent relationship. Four visible layers.
UtopikAI starts with a Main Agent, then gives that agent saved graphs, tools, workspace access, container-backed execution, published invoke paths, and review surfaces without hiding the operating model.
Build
Compose specialist behavior visually
Move complexity into graph topology instead of burying it inside one giant system prompt. Nodes, tool contracts, subgraphs, and branches stay explicit.
Graph topology replaces prompt sprawl
Wire
Treat MCP as a first-class system edge
Register project MCP servers for graph execution, then expose UtopikAI back out through MCP profiles and optional dynamic graph tools.
MCP in and out
Run
Make execution observable under pressure
Streaming events, run history, run steps, checkpoints, and published invoke snapshots turn execution into a process operators can trust and repair.
Runtime clarity beats AI theater
Learn
Keep memory and review inspectable
The memory hot tier, git-backed note store, reviewer runs, and node-review surfaces are in place. The full automatic end-of-turn write loop is the next rollout.
Foundation now, loop next
Five architectural bets
The differentiation is architectural before it is cosmetic.
UtopikAI competes with visual builders, learns from coding agents, and avoids the app-builder lane. The product lane is narrower and harder: agent systems that can be composed, owned, isolated, and audited.
01
Codegen over interpretation
Graph definitions generate LangGraph.js TypeScript project files with dependencies, state, nodes, and subgraph folders represented explicitly.
02
Container tenant boundaries
Provider-backed per-user execution and skills services give teams a clearer tenant boundary than shared workflow execution alone.
03
MCP-native from both sides
UtopikAI consumes project MCP servers and exposes builder, runner, codegen, discovery, full, and dynamic graph surfaces back to agents.
04
Skills as owned capacity
Drag in a skill folder or zip and the agent gains a concrete capability, scoped per user and per LLM node.
05
Review as visible system behavior
Reviewer agents, prompt versions, node reviews, and memory writes are modeled explicitly so critique can become an auditable product surface.
System anatomy
Prompting is only the conversation layer. The system underneath is the product.
01
Main Agent
Chat orchestrator, tool routing, active graph context, memory hot tier
02
Agent Graphs
Visual LangGraph topology, subgraphs, supervisor patterns, parallel branches
03
Execution Boundary
Workspace MCP, sandbox policy, per-user service boundary, checkpointed runs
04
Review Layer
Reviewer agents, node reviews, memory volume, git-backed history
Product surfaces
One Main Agent, multiple operational surfaces.
Chat, canvas, runtime, and memory are not separate products stitched together. They are one operating environment organized around the Main Agent.
Main Agent
The daily operator. Chat is the front door, not a sidebar utility.
Graph Canvas
The specialist designer. Structure explains behavior before anything runs.
Runtime View
The operational record. Streaming events, run rows, steps, checkpoints, and artifacts make execution debuggable.
Memory Loop
The system memory. Hot-tier context and a git-backed memory volume give review work a concrete place to land.
What this page must prove
This is agent infrastructure with product taste.
Visual LangGraph systems instead of one swollen system prompt
Published graph snapshots powering the Runtime Invoke API
Workspace-aware execution with explicit write boundaries
MCP profiles plus dynamic graph tools for external agents
Memory and reviewer foundations separated from roadmap automation
Anti-patterns rejected
No purple generic SaaS skin. No vague AI-builds-everything rhetoric. No speed-only positioning that hides container boundaries, ownership, and system behavior.
Market position
Built for the lane between visual automation and autonomous coding.
vs workflow tools
UtopikAI is not only a workflow editor. The graph has generated code, a runtime, run history, and a memory model behind it.
vs coding agents
UtopikAI is not another IDE assistant. It is the place where teams compose and operate their own specialist agents.
vs app builders
The output is not a full-stack app. The output is an agent system: callable, inspectable, and deployable.
Roadmap pressure
The next work is about making the Main Agent undeniable.
The foundation is already substantial. The near-term product push should make invocation, memory, review, published execution, and trigger lifecycle visible in the same experience.
01Deeper Main Agent sub-graph invocation UX
02Nested streaming cards for live specialist progress
03Automatic reviewer writes into memory
04Published graph rollback controls
05Webhook, schedule, and marketplace product surfaces
Final call