Main Sequence TAU SDK

Run Tau as a workspace-native Main Sequence coding agent.

ms-tau-sdk packages the Tau runtime integration, Main Sequence authentication and transports, and durable agent-session machinery as a normal Python dependency. A project installs the SDK and runs it from its own workspace—there is no separate Astro image, executor overlay, or second deployment model.

Quick start

Add the SDK to the project that will host the agent:

uv add ms-tau-sdk

Provide the runtime credential that Main Sequence assigned to the deployment:

export MAINSEQUENCE_ENDPOINT="https://api.main-sequence.app"
export MAINSEQUENCE_RUNTIME_CREDENTIAL_ID="<runtime-credential-id>"
export MAINSEQUENCE_RUNTIME_CREDENTIAL_SECRET="<runtime-credential-secret>"

Start the service from the project workspace:

uv run ms-tau

Install the version-matched development skills when a coding agent will work on the TAU integration:

uv run ms-tau skills sync --path .

This explicit command owns only .agents/skills/ms_tau_sdk/; package installation and runtime startup never modify the repository automatically.

The credential pair is exchanged for short-lived Main Sequence access tokens. Do not commit it or place it in .tau configuration. For an embedded ASGI deployment, construct the same application in Python:

from ms_tau_sdk import create_app

app = create_app()

Local development without platform sessions

Local mode runs the same workspace Tau runtime without registering an Agent or AgentSession. The project selects a provider and model explicitly, while Main Sequence still authorizes and hydrates the provider credential and supplies the live MCP catalog:

export MAINSEQUENCE_AUTH_MODE=jwt
export MAINSEQUENCE_ACCESS_TOKEN="<exported-user-access-token>"
export MAINSEQUENCE_REFRESH_TOKEN="<exported-user-refresh-token>"
export TAU_LOCAL_MODE=true
export TAU_LOCAL_PROVIDER=openai
export TAU_LOCAL_MODEL=gpt-5.4

uv run ms-tau

The normal Main Sequence login or project launcher may provision those JWT variables, but ms-tau-sdk does not install, import, or invoke the mainsequence Python package. It consumes the environment handoff and public refresh API directly. Provider secrets are never environment settings and are never persisted locally.

Local conversations and public A2A Tasks are stored at ~/.tau/mainsequence/<workspace-hash>/runtime.sqlite3; an omitted chat sessionUid uses the workspace default. Public A2A Message, Task, streaming, continuation, list/get/cancel, and subscription flows run without creating a platform AgentSession. Incoming local A2A calls do not need managed-gateway caller headers: supplied context IDs are mapped into the workspace-local session namespace and local provenance is recorded. Task records and event streams survive process restart.

Local mode also appends privacy-filtered, structured JSON Lines to ~/.tau/mainsequence/<workspace-hash>/logs/tau.jsonl, with bounded rotation. Both the database and log move under TAU_LOCAL_STATE_ROOT when set; neither is written to the project .tau or uploaded to a platform AgentSession. Console logging remains available.

Platform discovery of the unregistered process, internal backend dispatch/caller-delivery hooks, push notifications, and resume_caller remain unavailable. Outbound A2A through Main Sequence MCP supports Messages and Tasks with polling under authenticated-user semantics. Local mode binds to 127.0.0.1 unless a host was explicitly configured. Main Sequence MCP remains live, so its tools can still read or mutate real platform resources.

Workspace-owned Tau behavior

The consuming repository owns the effective Tau configuration. It can override the packaged Tau defaults and install project-specific tools through the normal .tau/ structure:

your-project/
├── .tau/
│   ├── SYSTEM.md
│   ├── settings.json
│   └── extensions/
├── pyproject.toml
└── uv.lock

Extensions run as project code in the same process and trust boundary as the rest of the repository. Optional capabilities such as general web access belong in a project extension; they are not bundled into the SDK. Main Sequence transport and protocol behavior remains SDK-owned.

Included capabilities

• FastAPI application construction and lifecycle management
• runtime-credential exchange, local user-JWT refresh, and authenticated Main Sequence access
• provider validation and credential hydration
• durable Tau sessions, leases, restore, persistence, cancellation, eviction, and shutdown
• local Tau execution without backend AgentSession pre-creation
• chat, SSE, A2A, health, and readiness transports
• Main Sequence MCP and protocol-required task controls
• packaged defaults that participate in Tau's normal workspace configuration
• explicit, version-matched development skills for repository integration, local debugging, project customization, and TAU's A2A host adapter

Deployment boundary

This repository publishes Python distributions only. It contains no Dockerfile, Compose stack, Kubernetes manifest, runtime image, executor bundle, or container-publication pipeline. The consuming project owns its dependency lock, deployable artifact, system dependencies, project code, prompts, skills, hooks, and extensions.

The project identity and migration are defined by ADR 56. See the quickstart, documentation index, and release guide for the complete contracts.

Development

The repository uses Python 3.13 and uv:

uv sync --frozen
uv run pytest
uv run ruff check .
uv run mypy

Releases are immutable and tag-driven. Pushing a tag that exactly matches the package version—for example, v1.0.0—builds and verifies the wheel and source distribution, then publishes them to PyPI through OIDC trusted publishing. No PyPI API token or container registry is involved.

Built on Tau

Main Sequence TAU SDK integrates the open-source Tau coding agent into the Main Sequence platform while preserving Tau's workspace-native configuration and extension model.