OrgX 0.2 turns live signal into momentum with clearer run visibility, richer skills, and Studio automation that keeps work moving.
Signal Mesh expands Live Ops, unifies agent execution, and adds a full Studio pipeline for brand-safe generation. It also tightens SDK integrations across ChatGPT (Developer Mode preview as of January 20, 2026) and Claude Code so external tooling feels first-class.
Focus areas for 0.2
The surfaces that bring Project OS together—unified rhythm, spacing, and language.
Live command center
Every run stays visible, every initiative stays grounded, and every handoff stays on pace.
Live Activity timeline
Watch runs, steps, and blockers as they unfold without refreshing.
- Processing states now stay visible while work completes.
- Event context is normalized so you always know what changed.
- Long-running flows stream updates instead of timing out.
Initiative and artifact context
Live views now surface why a run exists, not just what it did.
- Initiative descriptions stay attached to the activity feed.
- Artifacts and owners are linked directly in Live Ops.
- Timeline cards highlight the next best action.
Faster run history
Long run histories load quickly so you can catch up fast.
- Run detail pagination keeps deep histories snappy.
- Clearer status labels reduce “where are we?” moments.
- Fewer dead ends when drilling into artifacts.
Agent execution and orchestration
Runs are consistent across models, SDKs, and agents so teams trust the output.
Unified runners
The same run experience now works across supported SDKs.
- Unified execution supports Claude Code and ChatGPT Apps SDK.
- OrgX picks the right runner automatically.
- Runs stay readable regardless of model provider.
Two-tier agent model
Planning and execution are separated for clearer accountability.
- Context gathering is more predictable across runs.
- Handoffs preserve intent so decisions stay consistent.
- Child agent events are now cleaner and easier to review.
Reasoning-ready events
Reasoning-style output now streams cleanly into the console.
- Structured event conversion keeps summaries legible.
- Improved run turns track key decisions in context.
- Fewer “mystery steps” in long agent chains.
Skills and automation
Skills are easier to discover, easier to trust, and easier to replay.
Skill discovery and routing
Agents now find the right skill by intent with less manual setup.
- Routing checks capabilities before a run starts.
- Validation guards prevent mismatched inputs.
- Entity creation tools keep planning aligned.
Skill execution tracking
Every skill run now leaves an auditable trail.
- Usage logs link to the runs that triggered them.
- Prompt stacks assemble consistently for replay.
- Easier debugging when outputs drift.
Automatic evaluation loops
Artifacts are scored automatically so quality stays predictable.
- Evaluation configs run on autopilot.
- Quality targets flag regressions earlier.
- Robustness tests catch drift before shipping.
Studio and visual systems
Studio now ships brand-consistent assets faster without losing creative control.
Studio generation API
Generate content through a dedicated Studio pipeline, not ad hoc prompts.
- Brand ingest, orchestration, and outputs stay connected.
- Skill packs plug directly into Studio flows.
- Outputs are tracked for review and reuse.
Brand packs and asset references
Brand packs now include screenshots and references to anchor style.
- OrgX Amplify pack ships with live screenshots.
- Library references keep assets consistent across teams.
- Ingestion tooling speeds up new brand setups.
Graphics system and shaders
New visuals bring the OrgX metaphor to life without slowing pages.
- WebGL shader components are production-ready.
- Performance tuning keeps animations smooth.
- Marketing surfaces stay consistent across devices.
SDK integrations and MCP
External SDKs and connectors now behave like native OrgX surfaces.
ChatGPT Apps SDK connector flow
Connector setup is smoother and more reliable in Developer Mode.
- Developer Mode preview supported (as of January 20, 2026).
- Widget tools now surface with clearer metadata.
- Widget CSP allowlists cover tool domains.
Claude Code SDK integration
Run OrgX agents directly from Claude Code with unified runners.
- Consistent tool mapping across SDKs.
- Unified routing keeps behavior predictable.
- Runs stay traceable inside OrgX.
Protocol-agnostic tool endpoints
Tool execution behaves the same across transports.
- Tool names look consistent everywhere you use them.
- Only valid actions show up for each item.
- Runs are attributed to the right person.
Reliability and safety
More guardrails, clearer errors, and safer automation by default.
Session and service auth
Authentication now stays stable during long-running work.
- User auth persists in session for continuous access.
- Service-level auth supports production automation.
- OAuth-only enforcement removes unsafe fallbacks.
Connection health and error clarity
Runs fail less and errors explain themselves faster.
- Unified connection state machine reduces flakiness.
- SSE keep-alive improvements stabilize streams.
- Friendlier error handling reduces support loops.
Safety guardrails and CI hardening
Protection against destructive commands and regressions.
- Git Safety Guard blocks destructive commands.
- MCP smoke tests run in GitHub Actions.
- Worker deployment updates reduce drift.
Operating moments
Project OS steps in at every key moment so launches stay on beat.
Discover
Agent-first discovery surfaces skills, tools, and live signals instantly.
Plan
Unified planning and entity creation keep initiatives consistent.
Execute
Unified runners stream Live Activity as work progresses.
Evaluate
Automatic artifact evaluation closes the loop with quality checks.
Release notes
Short, scannable, action-led—so every team member knows what changed.
Highlights
- Live Activity now keeps runs, initiatives, and artifacts visible in one stream.
- Unified runners across SDKs with clearer execution and handoffs.
- Studio generation API, brand packs, and graphics system now ship together.
Agents and execution
- Two-tier agent model separates planning from execution.
- Reasoning output and child events stay readable in the console.
- Run detail pagination keeps deep histories fast.
- Agent-first discoverability helps teams find the right skills.
Skills and automation
- Skill discovery and routing now validate intent before execution.
- Execution tracking links skills to runs for replayability.
- Automatic evaluations add SLO monitoring and robustness tests.
Studio and design
- Studio generation API with orchestration and output tracking.
- OrgX Amplify brand pack with screenshot references.
- Graphics system and WebGL shader components in production.
- Amplify UI consistency and mobile navigation upgrades.
Integrations and reliability
- ChatGPT Apps SDK connector flow supported in Developer Mode (as of January 20, 2026).
- Claude Code SDK integration with unified runners.
- Protocol-agnostic tool endpoints and normalized tool names.
- Session auth persistence for MCP and production service identity.
Where to go next
Explore the new surfaces in action or wire Project OS into your stack.
Bring Project OS to your team
We onboard a small batch of teams each week. Join the waitlist and we'll help you wire OrgX into your launch rhythm.