Skip to content

Cross-account team projects: shared agent context and handoffs #48339

Open

Description

@InushaDeSilva

What variant of Codex are you using?

Codex App, with teammates using their own Codex accounts and local machines. The same collaboration model should be available to CLI and App Server clients.

What feature would you like to see?

First-class, opt-in cross-account project collaboration: people should be able to invite teammates to a Codex project and let their existing agents exchange bounded context, messages, and work handoffs without sharing an account or manually copying between chats.

My practical case is a system spread across several repositories and devices. Different people own the flight computer, ground software, and dashboard. I keep long-running Codex chats with design decisions and test history; a teammate has their own chats and agent. My chats can coordinate with other chats I own, but our two agents cannot join the same project-level coordination flow while retaining our separate identities, private histories, and local execution authority. A Git repository can hold curated documentation, but it does not deliver live handoffs or tell an agent which historical claim is current and verified.

An MVP could provide:

  1. A team project with invitations, member roles, and links to multiple repositories. Each person keeps their own Codex account, Git credentials, device access, and model usage.
  2. Explicit sharing of selected chats, summaries, decisions, and artifacts into a project knowledge view, including a reviewed bulk import of an existing project's chat history. Private conversations remain private by default. Shared facts retain source links, timestamps, owner, revision, and a way to mark them superseded or unverified. This should be retrieval into an agent's context, not an automatic merge of every transcript.
  3. Agent-to-agent messages, questions, and structured handoffs across members. Delivery is visible to both people, attributable to the sending agent and user, and durable when the recipient is offline. A handoff can include the owning repository, commit or PR, contract change, verification evidence, and unresolved work.
  4. Work ownership and overlap visibility across repositories. Agents can see who owns a component or task and ask for a handoff before editing the same area. Message delivery never grants repository or device authority.
  5. Separate permissions for reading shared context, messaging, editing a repository, and accessing a device or secret. The receiving agent still follows its owner's sandbox and approval policy. Credentials and full private chat histories are never copied to another member by joining the project.

For example, one person's agent changes a telemetry contract in the flight-computer repository. It sends the new contract and commit to the ground-software owner's agent. That agent can inspect the evidence, acknowledge it, and update its own repository. Both people can see the exchange and which version each agent used. Neither agent gets the other's SSH keys or blanket access to their chat history.

Additional information

This is distinct from #14923, whose cross-thread primitives were reported as shipped, because those operate on threads accessible to one account. #36472 proposes persistent workers and channels, and #23201 proposes scoped memory. This request is specifically about the boundary between different users and their agents: consent, identity, provenance, permissions, and handoffs across separate accounts and devices.

I would be interested in prototyping the workflow and sharing concrete findings. I understand from the contributing guide that the repository does not accept external code PRs, so I am opening this as a feature request and design discussion.

Activity

  1. added
    enhancementNew feature or request
    appIssues related to the Codex desktop app
    subagentIssues involving subagents or multi-agent features
    on Sep 26, 2026
  2. mahmoudalbustan1 commented on Sep 27, 2026

    @mahmoudalbustan1

    This is the gap we kept hitting too: the repo can hold curated docs, but nothing tells the next person's agent which decision is current or that someone already has a task. Until Codex has this natively, two habits help: log decisions in one append-only file where a new entry names the one it replaces, and have each agent claim a task in a shared list before it starts planning.

    Disclosure: I build Joxo (joxo.ai), which does this across people and machines today. Each person keeps their own Codex account, repo access and device; their agents share one project with decisions, a task board where only one agent can hold a task, and handoffs that carry the branch and commit. It also works if a teammate is on Claude Code or Cursor. Happy to compare notes on your MVP list.

  3. SnowyRoadAndy commented on Oct 17, 2026

    @SnowyRoadAndy

    @InushaDeSilva Disclosure: I'm building Braid. Your MVP list is close to how it works today. Each person keeps their own Codex (or Claude Code) on their own machine, under their own login and Git credentials, and nothing runs anywhere but the owner's machine. The agents join a shared channel with the humans, keep separate identities (every agent shows which human runs it), and hand work to each other in the room instead of through copied chats. Agents start read-and-reply only, and it works across organizations.

    We're a small team and it's early. Three owners across flight, ground and dashboard is exactly our case, so I'd like to set it up with you on a 15-minute call and see where it falls short.

  4. leonelngande commented on Oct 25, 2026

    @leonelngande

    Adding a related company-wide use case: shared working sessions, with software development as one example alongside operations, research, documents, and decisions.

    Today, valuable context accumulates in one person's AI conversation. A colleague should be able to join an explicitly shared session, ask questions, continue the work, or fork it with the relevant context and provenance intact. Sending a transcript or a PR does not preserve that interactive continuity. Nontechnical operations staff also need to participate: describe a problem, refine requirements with the agent, and follow the resulting work through human review.

    The difficult requirement is mixed access. Internal maintainers, external specialists, and operations staff must not all inherit the same access to repositories, documents, tools, or private conversation history. For example, a client developer should be able to request a backend change without gaining access to the backend source or the private implementation conversation. A privileged agent could carry out that work in a separately authorized private session and return only explicitly approved deliverables or status to the requesting session, with the responsible maintainer reviewing the private PR. The same distinction applies to confidential business documents and operational systems.

    Useful permission boundaries would therefore separate:

    • Viewing a session and its history, participating, continuing, and forking.
    • Requesting work from another team or agent versus reading that team's protected context.
    • Access to each data source and tool, executing changes, and approving or publishing results.
    • The private execution history from outputs explicitly released back to the requester.

    These should be enforced access boundaries, not instructions asking the model to keep secrets. Joining a session should not inherit its creator's credentials or authority. Membership changes, handoffs, execution identities, approvals, and released outputs should be attributable and auditable, with revocation supported.

    A practical acceptance case: an operations employee starts a shared request; a contractor clarifies it; an internal maintainer delegates protected implementation work; the employee and contractor can follow approved progress and outcomes without being able to query the protected source material. Authorized colleagues can also take over an ordinary shared working session without reconstructing everything from scratch.

    This would make shared context and cross-account handoffs useful across a company, beyond a shared coding session alone.

  5. SnowyRoadAndy commented on Oct 25, 2026

    @SnowyRoadAndy

    @leonelngande Disclosure: I'm building Braid, which I posted about above, so weigh this accordingly. Your boundaries are close to how it's built, so point by point:

    • Join, participate, continue, fork. A shared session is a channel. Colleagues, including non-technical ones, join it, talk to the agents in it, and can branch it into a new channel carrying only the context they pick. Nothing is sent as a transcript; the room is the continuity.
    • Requesting work without inheriting access. Each agent runs on its owner's machine with the owner's credentials, and only its owner grants it repositories, repo by repo. Someone in the channel can ask the maintainer's agent for a backend change; they never get the backend, and they never see the agent's private working session, because that session is on the maintainer's box and the channel only sees what the agent posts. That's the enforcement: structural, not a prompt.
    • Private history versus released outputs. Same split. The private execution history never enters Braid. What the agent posts to the shared channel is what's released. Honest gap: there is no per-deliverable "approve this output before it leaves" gate; today the release decision is the agent owner's, made by what their agent is allowed to do and share (file sharing, for example, is owner-approved).
    • Attributable and auditable, with revocation. Every message carries a verified sender. The org audit log records members added and removed, agent identities created and connected, credentials revoked, tokens issued and rejected, repo access, every file shared or downloaded, and every fork. It's hash-chained so edits are evident, and exportable as CSV or JSON. Honest gap: it's an org-level API and export, not a per-session timeline in the UI.
    • Your acceptance case (ops employee starts it, contractor clarifies, maintainer's agent does the protected work, the first two follow progress without querying the source) is the shape we built for, with the two gaps above.

    Small team, early, so no link. If you want to walk that acceptance case through it on a 15-minute call, I'll set it up and you tell me where it falls short.

  6. rotaker commented on Oct 30, 2026

    @rotaker

    @InushaDeSilva Disclosure: I made the tool I'm about to mention.

    Your issue describes what I built Susumiba for. It's an open-source project template that each person's own AI works in (Codex, Claude Code, anything that runs commands), each with their own account. Everyone's work lands in their own folder, and a clerk keeps one synthesis of who did what and what's left, every line pointing to its source. Your agent opens the project already knowing what the ground-software side did.

    It's built on git; the point is the synthesis on top. Honest limit: live updates are still experimental, so for now an agent sees others' work when it pulls.

    If you'd like to try it with your team on one project, paste this into Codex: "Read https://susumiba.com/ia.md and follow its instructions." Just curious? "Read https://susumiba.com/ia.md and tell me what it could do for me."

    — Pierre

  7. alexechoi commented on Nov 10, 2026

    @alexechoi

    Hey @InushaDeSilva, I build [Concord](https://github.com/Get-Concord-AI/concord-mcp) and I think [Concord Cloud](https://app.getconcord.ai) could help with the handoff you described. Your Codex agent can send the new contract and commit to your teammate’s agent in another repo, and they can acknowledge it from their own machine and Codex account.

    If you’re still up for prototyping this, I’d love to try it with you and share how it goes here!

  8. yorhaxxx commented on Nov 10, 2026

    @yorhaxxx

    Hi, I'm part of the pairpipe team, disclosure first: pairpipe has no users yet. We run a hosted relay for two people's agents: messages, shared files and a Brain both agents read. Messages from the other side are labelled untrusted. Claude Code is supported; Codex CLI is beta; the Codex App is untested, so I won't claim it. Founding Pairs: 6 months of Pro free, no card, for 15 minutes of feedback. An easy no is fine.

  9. dijarvrella commented on Nov 20, 2026

    @dijarvrella

    @InushaDeSilva We already support the shared decisions, ownership and handover part of your flight/ground/dashboard example in WorkLedger. I’m with Digital Disruptors, the team building it.

    The contract change, commit, test evidence and unresolved work stay on the project’s work item. A teammate can receive a structured handover showing what was decided, what remains open and what to do next; their connected Codex or Claude Code session picks up that recorded context.

    The shared surface is WorkLedger, alongside each person’s coding sessions. That gives the next owner an attributable starting point across teammates, tools and machines.

    We offer a free guided 30-day pilot, starting with one supported tool and repository. Your contract-change scenario would make a useful first handover to test:
    https://workledger-ai.com/early-access?utm_source=github&utm_medium=referral&utm_campaign=workledger-team-handoffs-2026-11-20

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    appIssues related to the Codex desktop appenhancementNew feature or requestmemorysubagentIssues involving subagents or multi-agent features

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions