Clarify the checkout boundary before a customer reaches it.
Collaborative coding agents
Turn team decisions into agent work.
Nuta brings people, coding agents, and the working sandbox into one shared thread. Keep the context, execution evidence, and rationale together.
- Shared context
- Visible execution
- Durable rationale
A shared agent, with clear boundaries
One thread. One working agent. A whole team.
People add the product and engineering context. The agent continues its thread-scoped session and live workspace while the work stays visible to the channel.
Maya · Product
Maya adds product intentAdd a usage limit that feels clear before a customer reaches it.
Jon · Engineering
Jon adds an engineering constraintKeep the entitlement check on the server and cover the edge cases.
Shared thread-scoped session
Codex continues the same session
Reads the shared thread context, updates the server-managed workspace, and reports the result.
Result everyone can review
Execution, files, and decision recordDecision, implementation evidence, and rationale remain connected.
Concept diagram — how teammate context flows into one shared, thread-scoped agent session.
A work record, not a black box
Inspect execution, then preserve the why.
Nuta keeps the deliberate conversation beside the agent’s working process, so reviews and handoffs start with the full picture.
- 01
Align in the thread
Bring product intent, constraints, attachments, and decisions into the conversation first.
- 02
Invoke a working agent
Continue a thread-scoped agent session and live sandbox instead of starting context over.
- 03
Inspect what happened
Read commands, output, diffs, tool calls, plans, and failures as the work progresses.
- 04
Preserve the rationale
Leave the decision record next to the result so the team can pick up the why later.
Collaboration with evidence
A shared surface for agent work.
Nuta turns the conversation into useful context and keeps the working process legible to the people shaping the outcome.
Shared thread context
A bounded thread history gives the agent the product and engineering context behind the request.
Inspectable execution
Review commands, terminal output, diffs, tools, plans, web searches, and failures in context.
Blocking approvals
Sensitive operations can pause for an explicit Approve or Deny decision from the right person.
Co-edit the same server-managed workspace
Choose VS Code or Zed from Nuta’s handoff, complete any required editor-side setup, and edit the same server-managed files together in real time.
Attachments with context
Bring the relevant artifact into the conversation so the agent sees what the team is discussing.
VS Code and Zed handoff
Open the same server-managed workspace in VS Code or Zed; if setup is required, complete it there before co-editing live.
Lifecycle controls
Inspect, interrupt, pause, or stop a sandbox with owner and admin controls; resume later when appropriate.
Branch the conversation
Fork a completed discussion into a new thread-scoped agent session without losing the original rationale.
Real-time co-editing, same workspace
Open the same workspace in VS Code or Zed. Co-edit live.
From a shared server-managed Nuta workspace, choose VS Code or Zed from Nuta’s handoff, complete any required editor-side setup, then edit the same files together in real time.
Nuta opens the in-product browser buffer for browsing and whole-file saves. Manual SSH setup is the manual connection/setup path when an automatic editor launch is unavailable. This section describes server-managed collaboration only; it does not make a BYOS collaboration claim.
Reviewable by design
See the process behind the answer.
Command output, diffs, tools, plans, web searches, MCP actions, subagents, durations, and failures stay connected to the conversation that asked for them.
The record helps a teammate review what happened without turning agent work into an unexplained handoff.
Compute with an explicit boundary
Choose how the agent gets a workspace.
Start with Nuta-managed compute or bring the scoped E2B profile that fits the thread. The two paths have different collaboration and trust boundaries.
Nuta-managed
Nuta-managed compute
Start with a managed working environment and keep its lifecycle visible alongside the team conversation.
- Thread-scoped workspace lifecycle
- Visible execution and controls
- Use the supported agent runtime for the thread
Available now on alpha
Bring your E2B compute
Choose a personal E2B profile and let Nuta provision a fresh, thread-scoped E2B sandbox for Codex App Server.
- Personal E2B API key and template
- Fresh sandbox provisioning, not attachment to an existing host
- Explicit untrusted-compute warnings before sensitive credential actions
User-provided sandboxes are untrusted compute. This current BYOS scope does not provide collaborators with file, editor, SSH, or lifecycle access in the owner’s BYOS turn.
Security and control
Controls that stay visible to the team.
Nuta keeps the work record accessible while preserving the narrower boundaries around sensitive decisions, credential actions, and sandbox lifecycle control.
Channel boundaries
Conversation and workspace access follow the channel boundary; approval authority is narrower than thread access.
Visible decisions
Approvals, command output, diffs, and failures remain reviewable in the work record rather than disappearing into a private run.
Configured sandbox policies
Owners and admins have lifecycle controls, while sandbox choice and credential actions keep their own trust boundaries.
Scoped credential handling
Stored model keys are encrypted, and compatible runtimes can receive scoped gateway tokens instead of raw provider secrets.
Owners and admins can inspect, interrupt, pause, or stop the sandbox. A later invocation can resume an eligible paused workspace.
Build with the whole thread
Give the agent the conversation it needs.
Request access to Nuta, or log in to the alpha if you already have an account.