tama

Your agents.
Working as one.

Tama brings your coding agents, plans and machines into one workspace. Define a plan, run connected tasks on your own workers, and review what changes.

Open Tama See how it works
Works withClaude CodeCodexYour accounts. Your machines. One workspace.
Fix the failing navigation testWaiting for you
S-12 · orbit-web · own branch session/12-nav · linux-01 · Claude Code
You · 10:22

The navigation test is failing. Find out why and fix it on your own branch, then show me what changed.

Tama · 10:31

The mobile menu stayed open after a link was chosen. I fixed the close handler on session/12-nav and added a test for the return journey.

Tama · 10:33
Hand back HB-12 to WEB-12
  1. ✓The task branch is still where this session forked. Nothing to reconcile.
  2. 2Commit 7d1e2a0 (2 files) goes to the task and becomes its next head.
  3. 3Required checks run again on 7d1e2a0 before review.
In design

Talk to an agent. Keep the work in view.

Ask an agent to investigate or fix something on its own branch. The task, its changes and its test results appear as cards in the conversation, and the agent asks before handing work back to the task.

Try the task, changes and tests cards, and the hand-back.

Recreated in HTML from the Tama console redesign, with sample data. No connection to your account.

From an idea to a plan.
From a plan to working software.

From the first “what if” to the final review, Tama connects the people,
agents and tools that move software forward.

In design

Ask. Build. Keep going.

Work with an agent in a focused conversation. Investigate a bug, explore a repository, or take a change through to review.

  • ↗Code, tasks and results in the same conversation
  • ↗Pick up the work with its context intact

Give the big idea a real plan.

Turn an idea into a clear project definition and connected tasks. Capture what success means before agents start implementing.

  • ↗Goals, constraints and acceptance criteria
  • ↗Dependencies that keep the work in order

Put agents to work in parallel.

Run tasks through defined workflows. Connect implementation, checks and review instead of managing disconnected agent sessions.

See what changed. Decide what ships.

Follow changes, check results and review findings back to the work that produced them. Keep approval where a person is needed.

Make your machines a team.

Connect macOS, Linux and Windows workers. See which machine is running a job, what is waiting, and where capacity is available.

The right agent for the work.

Configure runtimes, provider accounts and routing. Use Claude Code and Codex within the same workspace and follow their availability.

Keep an eye on the spend.

Track usage and charges across accounts and projects. See the cost of the work alongside the progress it is making.

Stay in your flow.

Use Tama through its MCP tools from a compatible client such as Claude Code or Codex. Bring task and workspace context into the tools you use.

FROM INTENT TO OUTCOME

Keep the momentum.
Keep the direction.

One continuous process, with room for you at every important turn.

01

Define

Describe the outcome. Shape a plan with clear boundaries.

02

Delegate

Give connected tasks to agents on your workers.

03

Verify

Follow tests, changes and review findings together.

04

Move forward

Make the decisions that need you. Keep the work moving.

Automation follows the plan. Decisions stay with you.
THE REST OF THE TOOLCHAIN

Source, builds and tests, built for agents.

Gin and Toki are separate tools with their own docs. Tama workers can already run Toki builds beside agent jobs, and Tama is moving its task source onto Gin. Their pages in the console are in design.

GIN · SOURCE CONTROL FOR AGENTS

Many agents. One graph of changes.

Gin gives every agent its own isolated workspace. A dependent task can start from its parent's published checkpoint before the parent lands, and move onto newer work when it chooses. Intent and context are kept as structured metadata, not commit messages. Git stays the system for people. Gin imports from Git and exports checkpoints as Git commits; a simpler sync, one diff in each direction, is being built.

In development

Read the Gin docs
Console design: a project's history as Gin holds it. Two dependent tasks are stacked on main with their checkpoints, and one merge records a conflict an agent settled.
Design for the Source page in the Tama console: Git history replayed beside Gin, with task stacks and checkpoints. Sample data.
TOKI · BUILDS, TESTS AND TEST HISTORY

Builds and tests on your machines. A history that remembers.

Toki runs whole build and test commands on your workers and records what happened: Cargo and rustc for Rust, and Node's test runner (node --test) for JavaScript and TypeScript, with more languages to come. It owns the test history. Results from Toki runs are recorded today; reading them back, importing CI results and asking about flaky or slow tests come next.

In development

Read the Toki docs
Console design: Toki test history listing flaky tests from Rust, Vitest, the Node test runner and JUnit, each with its signal, flake rate, platform and source.
Design for Toki's test history in the Tama console, with sample data.
TEST STUDIO

The experience matters, too.

Browser journeys written in plain language by agents or people, stored in the repository beside the code, and run on your workers.

In design

Console design: a list of browser journeys with their last twelve runs, the requirement each covers and its file in the repository.
Design for Test studio in the Tama console, with sample data.
A LITTLE SOUL IN THE MACHINE

More capable agents.
More room to create.

Tama takes its name from tamashī, the Japanese word for soul. The idea is simple: give powerful tools a shared purpose, and give you the space to think about what comes next.

THE DETAILS

Before you jump in.

A little more about the way Tama works.

What exactly is Tama?

Tama is a workspace for building software with coding agents. It brings conversations, project definitions, connected tasks, workflows, workers, checks and reviews together. You can work with an agent directly or coordinate a larger plan across several agents and machines.

Is it another coding agent?

Tama coordinates the agents and runtimes you configure, including Claude Code and Codex. It adds the shared plan, execution workflows, workspace context and visibility around their work.

Does my code stay on my machines?

Connected workers can run jobs on machines you own. The coding agent still sends prompts and relevant code to its AI provider as part of doing the work. Provider choice and account configuration matter; using your own worker does not make a provider-backed agent offline.

Can I use it from my terminal?

Yes. Tama exposes MCP tools for compatible clients. You can bring workspace and task context into clients such as Claude Code or Codex, as well as use the web application.

Is this the app I can use today?

Partly. Tama is in active development and moving to a new console. Plans with their task board and dependencies, project definitions, workflows, workers, routing, accounts, usage, budgets and the MCP tools are in the current app. Sessions and the simple home shown above are designs that are not in the app yet, and neither are the Gin, Toki and Test studio pages. The previews use sample data. No pricing or general availability is announced here.

YOUR NEXT IDEA HAS SOMEWHERE TO GO.

Build with a team
that moves with you.

Open Tama

Active development. A new way to work, taking shape.