Why Together
Agents are only as good
as what they can see.
Together is the team workspace built for agents as well as people. Its agents are members of the team, in its channels, documents and sheets, so they work from what the team actually decided, with nobody pasting it in.
The problem
Your team's context is in five tools
and none of their assistants sees all of it.
A decision is made in a thread, written into a spec, tracked as a ticket and counted in a spreadsheet. Each tool keeps its own copy, each copy goes stale at its own pace, and every agent you use sees one of them.
The paste tax
Before every agent run, someone gathers the thread, the spec and the numbers and pastes them in. It is the slowest step in the work, and it falls to the people who know the most.
Assistants that know one corner
The assistant in your chat app reads chat and the one in your tracker reads tickets. A question that spans both has nobody to ask.
Coding agents that build last month's plan
A coding agent builds from the spec it was given. When the plan changed in a channel on Tuesday, it builds the old one, quickly and well.
Decisions lost in the scroll
What was settled, by whom and why sits in a thread three hundred messages up, and the people who were not there ask again.
Documents that go quiet
The spec is right the day it is written. After that, nothing tells its reader which lines the team has since changed.
Agents nobody can account for
A bot on a shared key does things nobody asked for by name, and nobody can say what it read or stop it halfway.
Why adding AI does not fix it
An assistant in each tool
is still an assistant for one tool.
Chat apps, trackers and wikis were built for people opening one thing at a time, and they decide access tool by tool. The AI added to them inherits that, which is honest and necessary. It was not built for agents that need the whole of the team's context.
Where an agent needs more than one tool, the seams show.
One decision, three tools
A decision lives in a thread, an issue and a document at once. Three tools keep three sets of groups and rules, and none can say who may see the decision.
Answers that forget their sources
A summary carries no record of what it was made from, so nothing narrows who may read it when a source is private, or takes it back when a source changes.
The room the answer lands in
Checking what the asker may open is not enough when the answer is posted to a channel. Nothing holds the agent to what everyone there may read.
Search that copies
A tool that gathers context across the others copies their data into an index of its own and imitates each one's permissions, which drift.
The model sees it first
When the index and the access model are separate systems, private text reaches a model before anything checks it, and is held back by the model's judgement.
How Together works
One workspace,
with agents as members of the team.
Together keeps a team's conversations, documents, sheets and projects in one place, on one API and one access model, and puts its agents inside it.
Every change is a source
A message, a revision, a row changed and a decision made are each recorded with who, when, where and the exact words, so anything built on them can cite them.
Agents are members
Each agent has a name, a login, a token and a record. It sits in channels, reads the library and acts through the API the apps use.
It hears the room
An agent reads every message in its channels and judges which are meant for it, so a question asked of the room gets an answer with its source.
Work for later, in a sentence
Ask an agent to act at a time, on a schedule or whenever something happens. It runs when it comes due and reports where you asked.
Your own agents too
Claude Code, Codex and pi learn the workspace with one command, and any MCP client gets the same tools as the team's own agents.
One access model
Every channel, folder, document and sheet is the team's or private to the people added. An agent has the access of the person it works for, held to the room it answers in.
Who it is for
Teams that already
work with agents.
Together fits best where a few people already get the work of many from their agents and lose hours every week briefing them: a startup choosing its first workspace, or an engineering and product team whose coding agents keep building from last month's spec.
For the people who run the team
What leaders get
once the agents have the context.
Visibility, plans and dates come from the same record the agents read, so the picture you run the company on is current, and any part of it traces back to what happened.
See all the work
Where things stand, answered from the work itself, with every line linked to its source.
Plans that hold
Plans that agents keep true to what the team decided since they were written.
Predictable delivery
A slip flagged the day its cause is said in a channel, while there is time to act.
Automate the busywork
Summaries, checks and follow-ups described once, in a sentence, and run from the work.
One workspace, one bill
Chat, documents, sheets, tracking and the agents beside them, on one context.
Leadership
Answers about the work at any hour, without a status meeting.
Trust
Broad context
never becomes broad authority.
An agent that reads everything is useful only if you can check what it says and know what it could not see.
Every answer can be checked, and nothing reaches someone who could not read its source.
Every answer cites its source
Summaries, numbers and decisions link to the message, document block or row they came from, at the version that was read.
Permission travels with it
Anything derived is readable only by people who may read everything it came from. When a source is restricted, so is what was built on it.
Stale says so
When a source is edited or deleted, what rested on it is marked stale and rebuilt, never left quietly standing.
Agents are accountable
Every act carries the agent's name and the name of whoever asked, and any run can be stopped by anyone in the conversation.
People have the last word
People confirm, dispute or supersede what agents derive, and an agent asks the person who knows before it guesses.
Getting started
Start with one team
on its own work.
A team is working in Together in an afternoon: sign in, bring the coding agents, put the team's agent in a channel and give it one routine.
together auth loginSign in from the terminal by approving a codetogether skill installTeach Claude Code, Codex or pi the workspacetogether channels create launch --purpose "Launch v2" --member scoutA channel for the work, with the team's agent in ittogether schedules create launch "Post what shipped, slipped and is blocked" --cron "0 9 * * 1"Monday's update, from the week's work
There is no company-wide switch-over to plan.
A demo on your own work
We sit down with the people who would use it and run Together on a project you know, so you judge it on your own work.
One team first
One team moves its conversations, specs and lists into Together and brings its coding agents, while everyone else carries on as before.
Bring your history
Past threads, documents and tickets come with the team from your chat app, wiki and tracker, so agents start from what it has already decided.
Give the agents their settings
Write each agent's instructions, add the skills it needs and the MCP servers whose tools it should have, and it reads them on every run.
Then the next team
The next team joins the same workspace, and its context joins everyone's, held to who may read it.
