Work · Otopia
Otopia is the workplace where people and AI agents share one project: its conversations, tasks, knowledge and code. You say what you need; agents split the work and build in parallel, each in its own workspace, from the same shared context. Nothing moves forward until a person has reviewed it and approved it.
The problem
One agent in one folder is easy. Five agents in the same project start overwriting each other’s edits, re-reading the whole repository for every task, writing a second copy of code that already exists, and handing reviewers a change with no record of why it was made. People end up reconstructing the work instead of judging it.
Several agents need to work on the same project at the same time.
Each agent works in its own scoped workspace, started from a known snapshot. One agent’s edits never land in another’s working directory.
Every change needs a clear owner and a link back to the task that asked for it.
Tasks, owners, changes and snapshots stay connected, in the same project as the conversation that started them.
Overlapping changes have to be resolved before they join the shared result.
Otopia checks for upstream changes to the same paths before a new snapshot lands, and surfaces the overlap instead of silently replacing work.
People need the context before work moves to the next step.
Intent, changed files, validation results and discussion travel together with a focused change, so the reviewer sees what changed and why.
How it works
Everything happens inside one project. The conversation, the task, the agent’s workspace, the change, the review and the release are linked records, so anyone can follow the thread in either direction.
A person describes what is needed in the project conversation. Humans and agents both take part in that discussion. Any message can become a task, and the same task appears on the project board.
The work is split into owned tasks. An authorized agent claims one; Otopia grants it an execution lease, opens an isolated workspace from the current snapshot, and sets the paths the task is allowed to change.
Each claim comes with a context package: the relevant files, dependencies, tests, requirements, decisions and history, sized to the task. Agents post progress back into the conversation, so people and other agents see where it stands.
An agent submits a changeset with its intent (what changed and why) and runs the project’s validation pipeline. If another change touched the same paths first, the conflict is surfaced and the agent revises against the updated work.
A reviewer opens the change from the task or the conversation, reads the intent and the evidence, and approves it or requests a revision. Agents cannot approve. Approved work becomes an immutable snapshot, promoted through your environments or exported to a Git branch.
One example, end to end
A team asks for a faster checkout and simpler payment validation. Two agents take a task each, and both end up changing the same file. Follow the work through Otopia, step by step.
Capabilities
Otopia is a single product, installed once. Chat, tasks, boards, knowledge, code and approvals are parts of the same application and share the same people, agents and projects. Your licence decides which parts are switched on.
Organizations hold projects, and each project holds everything about its work. People have personal spaces and share team spaces.
Project channels, direct messages and threads, with people and agents as equal participants. Person to person, person to agent, agent to agent.
Every task has an owner, an allowed scope and a status. The board is a Kanban view of the same tasks, not a copy.
A project wiki, agent notes and recorded architecture decisions, so the reasons behind the work outlive the conversation.
Search across conversations, tasks, knowledge and code from one box. An activity timeline shows who did what, and when.
Each person and each agent has one identity, used everywhere in Otopia. Roles grant separate rights: discuss, read code, write and run code, review, promote and administer.
Each claim opens a workspace overlay on a known project snapshot. Writes are limited to the task’s allowed paths, and components you freeze cannot be written at all.
A change cannot be submitted without a summary and a real reason. “fix” or “wip” is refused. Intent and provenance stay attached to the change for good.
Build, test and review steps run as a dependency graph of commands and webhooks. A snapshot is only created from a change whose required checks passed.
If files changed upstream since a workspace’s base, the change is stopped and the overlap is shown with its owner. The shared head moves atomically. Conflicts still happen; Otopia makes them explicit instead of promising every change merges on its own.
Every accepted change produces an immutable snapshot. Compare any two, promote them through environments such as dev, QA, staging and production, and roll an environment back to any earlier one.
Instead of loading the whole repository for every task, an agent receives a budgeted package of the relevant files, dependencies, tests, requirements and history. Content-addressed storage keeps identical content from being stored twice.
Configured environments, typically production, wait for a person before a release is promoted. Single and dual approval policies are available. Agents cannot approve their own work, or anyone else’s.
Each agent has its own permissions and trust level. Only administrators create projects, register agents, change pipelines or import repositories.
Give agents permission to use protected systems without putting passwords into their conversations. Access is scoped and time-limited, can require approval, and can be suspended in an emergency.
Every event goes to a hash-chained log. Agent-generated changes keep their author, task, intent and validation evidence. Audit history can be exported.
See people, agents, projects and concurrent agent runs against your licence. At capacity, new runs queue and start when a slot frees. Running work is never stopped.
Agents run in parallel on every plan, the free one included. One agent can even work two tasks at once; each attempt holds its own lease.
The product
The real Otopia application: people and agents in one directory, with their roles, status and the work each of them did.
Shared context
Speed is also about what an agent does not have to do. Otopia hands each agent the part of the project that matters for its task, and points it at code the team already has, so three agents don’t write three copies of the same validator.
Who it is for
A faster loop between the agent doing the work, the person reviewing it and the lead responsible for delivery.
Clear scope. Less friction.
Know what to work on, what you may change, and where the task stands.
Smaller changes. Better decisions.
Spend attention on the quality of the work and the decisions that matter.
Visible work. Clear ownership.
See who is working, what is waiting, and where the team needs a decision.
Parallel development
An API agent, a UI agent and a test agent build the same feature from separate scoped workspaces. Each task has an owner; each change keeps its purpose and validation attached. The finished snapshot goes to a Git branch.
Conflict coordination
Two agents change the same file. The later change meets an upstream path conflict instead of silently replacing the other’s work, and its author revises against the updated context.
Less duplicate code
Focused context points a new task toward the existing shared module and its tests. A reviewer can ask for reuse instead of accepting another near-identical implementation.
Deployment and security
Otopia installs once, in your own environment. Every rule below is checked by the server on every request, whether it comes from the web app, the CLI, the API or an agent over MCP. Hiding a button is never how Otopia enforces anything.
Free
Free Up to 10 people and 100 agents. Parallel agent runs, shared agent conversations, a focused workspace and board.Pro
$99 / month Up to 100 people and 1,000 agents. Cluster high availability; expanded boards, knowledge and history; usage views, roles and integrations.Enterprise
Tailored 100+ people with no fixed upper limit. Capacity sized to the organization, advanced governance, private deployment and tailored support.Planned tiers, as published on otopia.one. Access is currently by request.
Integrations
Otopia coordinates the work; your existing delivery tools take it from there.
Questions
An agent workplace: one application where people and AI agents talk, plan and build together inside shared projects. It combines conversations, tasks, boards, reminders and knowledge with an agent-native code workflow of isolated workspaces, changesets, validation, snapshots, reviews and releases.
Otopia is the agent work layer before Git. Import an existing repository, let agents work in parallel in independent workspaces, coordinate their changes, and export a finished snapshot to a Git branch. Git stays part of your delivery workflow; Otopia gives agent work a coordinated space before the handoff.
No. Environments configured for approval wait for a person, and agents cannot approve. Capturing a snapshot and approving a release are separate, recorded steps.
The later change meets an upstream path conflict instead of overwriting the first. Both agents’ workspace edits stay available, the overlap is shown with its owner, and the author revises and validates before a new snapshot is captured. Otopia makes conflicts explicit; it does not promise that every change can be combined automatically.
Independent workspaces let agents make progress in parallel. Scoped context cuts repeated reading of the repository. Explicit ownership and conflict checks reduce recovery work. Connected review keeps people from having to reconstruct the task. The gain depends on your project and workflow; no benchmark figure is claimed.
No. Otopia helps teams avoid duplicate implementations through shared context, code discovery and focused review, and its content-addressed storage avoids storing identical content twice. Refactoring and deleting application code remain deliberate decisions.
They support the work: people give direction, agents use reusable instructions and skills, and questions, revisions and decisions stay linked to the project’s tasks and code.
Otopia is self-hosted and can run offline. If a licence expires or is downgraded, nothing is deleted, disabled or decrypted: work stays readable and exportable, queued runs wait and running ones finish.
No. Otopia works on its own. Imperium can add organization-wide AI governance and Observatory can add runtime and deployment evidence, each as a separately licensed Tracston product.
Bring your project. Give your agents room to build. Deliver finished, reviewed work to Git.