Your Agent Subscription Isn’t Your Only Option
If you work with AI Agents, you probably use more than one. You use Claude Code for development, but you also want Codex for code review. Or your main Agent is Codex, but certain tasks just feel better in Claude Code.
The problem: you aren’t going to buy a subscription for every Agent. Claude Code Pro, Codex Plus, assorted API costs, it adds up fast. So most people pick one, hit the limit, and wait it out.
In Tutti · VM, there’s another way.
Borrowing: Use Someone Else’s Agent in a Room
When would you need to borrow someone else’s Agent? At least three situations:
Your Agent hit its hourly limit. Codex or Claude Code stops mid-task because the quota ran out, the work isn’t finished, and you don’t want to just sit there. Borrow a friend’s same Agent right in the Room and keep going, no switching devices, no switching accounts.
You want an Agent you don’t have. Your main tool is Codex, but this task would go better in Claude Code, and your friend has a Claude Code subscription. Borrow theirs in the Room, and it feels exactly like using your own.
Your friend’s Agent is set up better than yours. They spent a long time tuning MCP, skills, and system prompts for a certain kind of task. Instead of working it out from scratch, borrow their Agent and get the benefit of the setup they already dialed in.
How to Borrow
You and a friend (or teammate) are in the same Room. They’ve turned on Agent borrowing, so you can invoke their Agent directly.
It’s simple: pick their Agent in the Room, and from there it works just like your own, send commands, watch the process, get the results. When you’re done, whoever granted access can take it back at any time.
Why a Borrowed Agent Feels No Different From Your Own
This is the crux.
You might be thinking: group-chat products also let you pull an Agent into a group and @ someone else’s Agent, isn’t that the same thing?
The difference is depth. An Agent call in group chat stays at the message layer: you ask a question, it answers; you tell it to do something, it finishes and hands you a summary. You can’t see how it worked, only the final result. That’s closer to “asking someone else’s Agent a question.”
In Tutti · VM, borrowing means using someone else’s Agent to do your own work, and the whole process is visible in real time: every command you send, every step the Agent takes, which files and which lines it changes, what the preview looks like, whether anything errored. It’s exactly like using Claude Code or Codex yourself, with full visibility and control over the process.
And because every Agent is virtualized into the Room through connection and runs its tasks there, the instructions, the process, and the results all live in the Room by default. The borrowed Agent can reference your earlier work state directly:
- What’s being said: your earlier conversations with your own Agent, the approaches you weighed, the decisions you made.
- What’s being done: which files are being changed right now, how far the task has gotten, the current state of the preview.
- What’s done: the code, images, documents, and design files already produced.
The borrowed Agent sees all of it as if it had been on the project from the start. No re-briefing, no “let me summarize the background first.” Just tell it what to do next.
This Isn’t an Account Transfer
Borrowing is a delegation of capability, not account sharing. Whoever granted access can revoke it at any time. Your Agent accounts stay in your hands, and theirs stay in theirs.
Specifically:
- The owner turns on Agent borrowing in the Room settings.
- The borrower picks the owner’s Agent to use inside the Room.
- The owner can revoke access at any time.
- All the work state produced while borrowing stays in the Room; it doesn’t follow the Agent back.
When you borrow a friend’s Agent, their skills, MCP configuration, and tools come along with it, so the working environment they spent time tuning is available the moment you borrow it, with nothing to set up yourself. That is capability sharing in itself: through one act of borrowing, the best practices one person worked out become usable capability for everyone else in the Room.
How This Differs From Other Approaches
The usual answer to “not enough Agent quota” is to buy more quota, or to switch to a platform’s built-in Agent (API mode).
The first costs more money. The second means switching tools, the MCP, tools, and skills you carefully set up in Claude Code all have to be redone on the platform’s Agent.
Tutti · VM works differently: you don’t switch tools, you don’t pay extra, you just borrow capability that already exists inside the collaboration space. Because of BYOS (Bring Your Own Subscriptions), everyone brings their own subscription in, and borrowing simply shares on top of that.
Where It Fits
- Inside a team: a developer borrows an ops teammate’s spare Agent quota (a real need on our own team).
- Between friends: you have Claude Code, they have Codex, and you borrow each other’s to fill the gaps.
- Temporary collaboration: borrow for the length of a project, revoke access when it wraps.
- Reusing a setup: a friend has tuned the perfect configuration for a kind of task, so you borrow their Agent and get it directly.
In Short
Agent borrowing solves one core problem: capability shouldn’t be walled off by subscription boundaries.
The Agent capability you have, you can lend to others through the Room. The capability you’re missing, you can borrow back. No repurchasing in between, no switching tools, no reconfiguring, no re-explaining the background.
