ttal

TTal

Agent ops for multi-repo teams. One binary. CLI-native.

Most agent tools assume one repo, one session, one task. Real projects span multiple repos, multiple languages, multiple deployment targets. TTal coordinates agents across all of them — routing tasks, spawning parallel workers, shipping PRs — while you manage everything from Telegram.

task → research → design → implement → review → merge → cleanup

What it does

• Route tasks to the right agent — researcher investigates, designer plans, worker implements
• Spawn workers in isolated git worktrees — parallel execution across repos, zero conflicts
• Ship PRs with automated review — specialized reviewers for security, tests, types, edge cases
• Manage from Telegram — approve, merge, redirect, all from your phone
• One command drives everything — ttal go advances any task through its pipeline

# Create a task
ttal task add --project myapp "Add JWT authentication to the API"

# One command drives every transition
ttal go abc12345

# Pipeline routes it: research → design → implement → review → merge
# You review verdicts on Telegram, approve, done

Multi-repo, not monorepo

Multi-repo coordination is a known pain point — Claude Code assumes one session per repo, and there's no native way to plan across repos, share context between sessions, or coordinate branches.

TTal solves this with a project registry and a coordination layer:

# ~/.config/ttal/projects.toml
[ttal]
name = "TTal Core"
path = "/code/ttal-cli"

[organon]
name = "Organon"
path = "/code/organon"

[temenos]
name = "Temenos"
path = "/code/temenos"

Register your projects once. TTal handles the rest:

• Cross-repo context — ei ask --project organon "how does src handle markdown?" spawns a sandboxed agent in any project. Research without polluting your main session.
• Session forking — brainstorm a feature in one session, fork it into project-specific planning sessions. Each fork carries the full conversation — every decision, every "actually, let's not do that" — with zero context loss.
• Parallel workers across repos — a feature that touches three repos gets three workers, each in their own git worktree, each sandboxed to their project. They can't see or step on each other.
• CI integration — workers subscribe to check status. When CI fails, the daemon delivers the log directly to the worker's session. They read it, fix it, push again. No human in the loop for lint and test failures.

A cross-repo feature that touches TTal, temenos, and organon gets three parallel workers, three PRs, three review cycles — all coordinated through one pipeline.

How it works

Two planes, borrowed from networking's control/data plane separation:

Manager plane — persistent agents that hold the big picture. They know what features they designed with you, which tasks are blocked, what shipped yesterday. Managers never touch code.

Worker plane — ephemeral sessions that implement. Each gets its own git worktree, sandboxed environment, and tmux session. Spin up, do the work, merge, clean up. Workers never worry about the big picture.

Message bridge — Human ↔ agent via Telegram. Agent ↔ agent via ttal send. CI status, PR reviews, task updates — all routed through a single daemon. You talk to your agents like coworkers in a group chat.

┌─────────────────────────────────────────┐
│  TTal         orchestration layer       │
│               tasks, workers, pipeline  │
├─────────────────────────────────────────┤
│  organon      instruments               │
│               src, web (structure-aware)│
├─────────────────────────────────────────┤
│  logos        reasoning engine          │
│               bash-only agent loop      │
│               any LLM, no tool schemas  │
├─────────────────────────────────────────┤
│  CC sandbox   the sacred boundary       │
│               seatbelt / bwrap          │
│               OS-native, no containers  │
└─────────────────────────────────────────┘

Each layer does one thing. TTal orchestrates. organon perceives and edits — structure-aware, not text-aware. logos thinks — bash-only reasoning, works with any LLM. CC's native sandbox isolates — no containers needed.

The team

TTal agents aren't chatbots. They're specialists with clear roles:

Agent	Role	What they do
Yuki 🐱	Orchestrator	Routes tasks, manages the pipeline
Athena 🦉	Researcher	Investigates problems, writes findings
Inke 🐙	Designer	Reads research, writes implementation plans
Workers	Coders	Spawn per-task, implement, open PRs, self-cleanup