Tutti (3.1K★) Ends Copy‑Paste Chaos: A Unified Workspace for Claude Code and Codex

The article analyzes how the open‑source Tutti Agent OS eliminates repetitive copy‑paste and context hand‑over across multiple AI agents by providing a real‑time shared workspace, detailing its architecture, core features, installation methods, real‑world use cases, advantages, and current limitations.

AI Architecture Path
AI Architecture Path
AI Architecture Path
Tutti (3.1K★) Ends Copy‑Paste Chaos: A Unified Workspace for Claude Code and Codex

Developers who switch between multiple AI agents (e.g., Claude Code for backend and Codex for frontend) often repeat copying interface definitions, re‑explaining requirements, and juggling windows, which consumes a large portion of productive time.

What is Tutti?

Tutti (named after the musical term “tutti”) is an open‑source Agent OS released in March 2026 under the Apache 2.0 license. It does not create new models or replace Claude Code/Codex; instead it provides a real‑time shared workspace that lets all agents access the same files, conversations, tasks, and built‑in applications. The project has 2.1 k Stars on GitHub and runs on macOS only.

Technical Architecture

Electron desktop client : renders the GUI, handles window management and file interaction.

Go daemon tuttid : a resident background process that orchestrates tasks, manages agent sessions, and stores all data locally in SQLite.

Three communication channels :

HTTP – reads authoritative conversation, task and file data; guarantees persistence and reconnection safety.

Business WebSocket – pushes real‑time agent events and task changes; only notifies state changes to reduce token consumption.

Terminal WebSocket – streams raw terminal byte streams, preserving full interaction semantics.

Core Reference Mechanism

Instead of embedding whole files in prompts, Tutti uses an @ handle that expands to a lightweight mention://workspace-reference/ URI. Agents resolve the reference on demand, preventing prompt bloat and context overflow.

Three Core Functions

Real‑time shared workspace : typing @ in the input box instantly pulls any previous agent conversation, local file, generated artifact, or pending task. A + button adds local files, AI‑generated images, or prototype drafts to the current context.

Built‑in application ecosystem : AI Canvas (image generation), Prototype Design (UI sketch), AI Doc (document drafting), and AI PPT (presentation generation) can be operated manually or invoked by agents, reusing the user’s existing Claude/Codex subscriptions without extra cost.

Automatic task orchestration & global control center :

Goal‑to‑Tasks – a single goal (e.g., “build a corporate website”) is automatically broken into sub‑tasks such as copywriting, design, backend API, frontend implementation, and image creation.

Control Center – a single window aggregates all agent dialogues, running tasks, pending approvals, and blocked nodes, allowing a 14‑inch laptop to monitor an entire project.

Issue → Task → Run – an Issue represents the overall work theme, a Task is an executable unit, and a Run is a single agent execution; failed runs retain their original plan for retry.

Installation Guide

Binary (recommended for most users)

Download the DMG from the GitHub Releases page (https://github.com/tutti-os/tutti/releases) or the official site.

Install the DMG and launch the Tutti client.

The app automatically scans for installed Claude Code and Codex CLI, reusing existing login sessions and subscription quotas.

Create a local workspace, select an agent or built‑in app from the bottom bar, and use @ to start cross‑agent collaboration.

Source compilation

git clone https://github.com/tutti-os/tutti.git
cd tutti
pnpm install
pnpm setup:dev
make dev-gui

Requirements: Node 24+, pnpm 10.11.0, Go 1.24.

Supported Agents (as of writing)

Stable: Claude Code, Codex

In development: Hermes Agent, OpenClaw, Gemini

Non‑subscribed users can use the early‑access free agent (subject to future usage‑based billing).

Comparison: Local Open‑Source vs. Future Cloud‑Collaboration VM

Use case : local version targets single‑person, multi‑agent development; cloud version targets multi‑device, multi‑person team collaboration.

Data storage : local stores all conversations/files on the machine; cloud version syncs state to a cloud “Room” while agents still run locally.

Sharing scope : local interconnects agents on the same machine; cloud shares resources across devices and users within a Room.

Core capability : local eliminates information islands for a single user; cloud adds preview sharing, @‑colleague dialogue, and cross‑device task continuation.

Privacy boundary : local keeps everything private; cloud shares only Room content, leaving other local workspaces isolated.

Subscription model : both reuse personal agent subscriptions; cloud allows each party to use its own subscription with optional quota sharing.

Four Real‑World Scenarios

Full‑stack development across agents : Claude Code writes the data model and API, then @history lets Codex read the API spec and generate the frontend, followed by automated regression checks.

Prototype‑to‑code pipeline : Prototype Design creates a UI sketch; Codex directly consumes the sketch to produce the page, eliminating Figma export, screenshot, and upload steps.

Parallel project management : Simultaneous code refactoring and documentation tasks are monitored in the Control Center; human intervention occurs only for approvals, drastically reducing window switching.

End‑to‑end content production : AI Doc outlines an article, @AI Canvas generates accompanying illustrations, and @AI PPT converts the whole package into a presentation without any file export loss.

Limitations & Pitfalls

Only macOS is supported; no Windows client yet.

Local version lacks container or VM‑level isolation – third‑party apps should be granted permissions cautiously.

Agent support is currently limited to Claude Code and Codex; other models are still under development.

Cloud‑collaboration features (Tutti·VM) are pending release.

Running many agents simultaneously can consume significant memory, causing slowdown on low‑spec Macs.

Conclusion

The primary productivity bottleneck for multi‑agent workflows is fragmented information flow between agents. Tutti addresses this by providing a lightweight shared‑collaboration layer that removes copy‑paste, context repetition, redundant subscriptions, and window clutter, potentially cutting 80 % of unnecessary operations.

GitHub: https://github.com/tutti-os/tutti
Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

AI agentsopen-sourceCodexagent collaborationClaude CodeTuttireal-time workspace
AI Architecture Path
Written by

AI Architecture Path

Focused on AI open-source practice, sharing AI news, tools, technologies, learning resources, and GitHub projects.

0 followers
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.