The nerve center for agentic engineering

Every coding agent runs its own session with its own picture of the repository. Point two at the same codebase and they edit the same file from different assumptions. The engineer ends up as the messenger between chat windows.

Context dies when a session ends, so the next run starts by re-explaining the codebase. Every additional agent makes this worse, not better.

First you wrote the code, one line at a time. Then you prompted it, one chat at a time. Now engineers run several agents at once, and the tools still assume one person, one file, one cursor.

Each new agent on the market is another session, another subscription, another silo. The coordination layer is missing, and it cannot be a plugin inside the thing it replaces.

NALA connects the coding agents engineers already pay for and runs them as one fleet: one task board, durable sessions, explicit approvals.

Sessions live in a detached daemon. Close the app, reboot the machine, and every terminal, scrollback, and conversation returns where it was.

Work is broken into tasks an agent claims, so a claimed task is visibly owned and two agents never start the same thing.

Agents hand off through durable messages that survive a restart, acknowledged end to end. Each department works in its own git worktree, so parallel edits do not collide on disk.

No agent spawns another without your signature, and every approval is single use.

The beachhead is engineers already paying for two or three coding agents and losing hours reconciling them. They do not need convincing that agents work. They need the layer that makes agents work together.

From there the surface widens: any team that adopts agents inherits the same coordination problem, and the orchestration layer sits above every model provider at once.

Bring-your-own keys travel from your machine straight to the provider: never stored, never proxied, never logged, never in a support bundle.

We do not sign in to providers for you, and a provider subscription cannot be routed through us. That is an architectural line, not a policy promise.

The desktop app and terminal agent are free and stay free. NALA does not resell inference, so the free product never has to be crippled to survive.

For engineers who would rather not manage keys, a metered gateway is built and deliberately switched off until the economics and the terms have been checked. Distribution first, monetization second.

A Windows build is published and downloadable now, through a one-line installer that verifies the exact SHA-256 before anything runs. Builds are currently unsigned, so the OS warns on first install; the checksum is published with each release.

The orchestration layer is shipping code: task claiming, durable handoffs, single-use approvals, an MCP harness with 30+ tools, and 40+ built-in agent roles.

Next is macOS and Linux through the same digest-verified pipeline Windows already uses, plus code signing so installs stop triggering OS warnings.

Then depth in the orchestration layer: richer departments, longer-running work, tighter cost control. Hosted workspaces stay research until the credential and spend questions have real answers.