Type asq and you get your projects on the left and, on the right, a manager agent you task in prose. It plans, spawns coders, testers and reviewers, and loops until the goal is met — then stops, because merging is yours. Click any agent and you are inside its real Claude Code session, typing at it directly. Nothing is relayed or re-rendered as a chat.
$curl -fsSL https://raw.githubusercontent.com/AISquare-Studio/aisquare-cli/main/install.sh | sh
macOS, Linux, WSL2. It works out what the machine already has, installs only what is missing, and ends by offering to open the UI. Run it again and it installs nothing.
Six sessions, one project, one window. Close the UI and every one of them keeps running — tmux is the substrate, not a rendering trick.
5roles in the loop
1SQLite file of state
0daemons, accounts
what a fleet of agents costs you today
Every session starts cold.
You re-explain the codebase, the conventions, and the thing you already told it last week. The agent greps its way back to what it knew yesterday, and you pay for that in tokens and in patience.
Memory. Five lifecycle hooks start each session with a packed snapshot of the repo, your context entries and the project's prompt history. Zero commands after setup.
You are the message bus.
One agent per terminal. Five agents means five terminals, five mental models, and a human copy-pasting findings between them — which is the part that does not scale.
A shared board. Contract-carrying tasks, atomic leased claims, and a per-prompt delta of what teammates did. Nothing needs forwarding.
Nothing is on record.
When an agent did something you did not want, you cannot read back what it was shown, what it decided, or what it cost. So the same mistake arrives again next month.
Explainability. Every session becomes a Run you can read — prompts, tool calls, tokens, cost, plus your own prompts and board events. Opt-in, and it never blocks a launch.
The board is the only channel. The manager writes contracts and reads deltas; it never writes code and never merges. The load-bearing edge is the amber one: the tester runs the full check the contract names, tries to break the change, and its reopen reason rides back to whoever claims the task next — with no human relaying it.
Prose is a terrible protocol — a watcher grepping READY fires on a note saying NOT READY.— why board signals are first-class named states, not string matching
Availability is probed, never assumed, and a rung is demoted only on proof of substitution. The validator carries a +1 effort offset for one reason: a gate has to outrank the work it checks.
the manager, mid-goal, in one window
The real fleet UI. Left: every registered project and the agents under it, each with a live state chip. Right: the manager's own Claude Code session — the goal that was typed at it, the orientation it was handed, the five contracts it wrote, the agents it spawned, and the tester's reopen coming back through the board. Project data and pane transcript are a worked example, not a customer's repo.
why you can put this in a real repository
Fail-open, by construction
Any error inside a hook is swallowed and the session continues untouched. A repo that never opts in sees nothing at all.
One file, no daemon
All state is ~/.aisquare/context.db in WAL mode, concurrency-tested against racing parallel sessions.
Everything is a command
Every action the UI takes is a plain CLI command, and every command takes --json. Scripts never meet a full-screen app.
Receipts you can re-prove
Every write prints ✓ … seq N; team verify 42 asks the board whether that is really there, and exits 0 or 1.
Read-only where it matters
The reviewer runs --restricted in its own worktree. The coder's tree is never moved under another agent.
Every check names its fix
aisquare doctor reports every dependency and prints the exact command for anything missing.
Roadmap stays hidden
Unfinished commands are hidden from --help and exit 70 saying so, rather than half-working. What is listed, works.
Contracts, not vibes
The server's JSON Schemas are vendored byte-for-byte and every request the CLI can emit is validated against them in CI.
where this is going, stated plainly
Now · v0.6.0
The fleet UI, and the manager loop end to end
Memory: two context pools, packed snapshots, prompt history
Board: contracts, leased claims, receipts, named signals
Model ladder per role, probed, with effort offsets
Several accounts driving one board
Remote agents over MCP; Explainability Runs
Next
Sign in: one identity across your machines
sync — memory that follows you, and your team
On-limit handoff: a seat runs out, the work moves
Remote control: watch and steer the fleet off-terminal
The mechanics already exist — leases release on session end, and a seat is a binary plus its environment.
Later
Connectors: meeting notes and tickets into the knowledge base
Org policy the agents cannot cross
A knowledge graph of findings, decisions and preferences
Collective Intelligence is live against a staging server today, off by default, and measuring nothing yet. We will say when that changes.
a pilot is one repo and one afternoon
$ curl -fsSL …/install.sh | sh # installs only what is missing$ asq # the UI; click + and point at a repo… then type your goal at the manager, in prose.
what it needs from you
A Claude Code login your developers already have, tmux 3.2+, git and gh. Nothing to deploy, no account to create, no traffic leaving the machine unless you switch that on deliberately.
next step
Pick one repository with real parallel work in it. We will sit with a team for an afternoon, run the loop on a live goal, and hand back the transcript and the Runs.