OrgX
The flagship platform: multi-agent orchestration, trust governance, and proof-first operator surfaces.
OrgX is the clearest expression of how I think about agent infrastructure. Delegate aggressively, keep provenance visible, and make the review surface strong enough that human judgment can stay precise instead of becoming a bottleneck.
What the platform actually does
OrgX treats the organization, not the single prompt, as the primitive. Tasks turn into workflows. Agents become operating actors with tool access, trust boundaries, cost footprints, and quality history.
The value is not just that the system can delegate. The value is that delegation stays legible: you can see what was routed, which tools were used, what quality bar was applied, and where a human stepped in.
- Spawn and route specialist agents without losing context.
- Gate autonomy through trust tiers instead of hard-coded fear or blind freedom.
- Carry decisions, learnings, and costs forward through org memory and outcome attribution.
trust tiers
strict -> read, analyze, propose; no mutation without approval
balanced -> low-risk mutation allowed; medium risk escalates
open -> full autonomy inside tool and budget guardrails
spawn guards
max_agents_per_task: enforced
budget_per_run: enforced
human escalation: required for destructive actionsThree layers keep the platform honest
OrgX architecture
Events drive durable execution, governance decides what can happen next, and the intelligence layer records quality, cost, and memory.
The product surface is part of the system
The important architecture choices
These choices are pragmatic, not theoretical. They favor a solo builder's ability to ship and observe the system without drowning in platform maintenance before the product proves itself.
The throughline is the same one I want in my next role: build the substrate that makes autonomy trustworthy, then build the operator surface that proves it.
- Inngest over Temporal to keep workflow durability without running separate orchestration infrastructure.
- Supabase over a custom backend to get real-time subscriptions, auth boundaries, and velocity in one system.
- MCP as the protocol layer so tools are discoverable and portable across clients instead of rewritten per runtime.
OrgX is the system I’d build again from scratch tomorrow.
If you're hiring for agent infrastructure, this is the work I want to do next: orchestration, governance, observability, and the interface layer that makes serious automation usable.