NewAgio for macOS, Windows and Linux

Coding agents. Inside your app.

Agio is the agent core of NSGo apps: it runs pi, Codex, Claude Code and CodeBuddy Code, and shows their work on phones and desktops. Agio, the app, is that core on its own — to try, to test, or simply to use.

Free and open source · MIT · Updates itself

Works with the agents you already use

and any Agent Client Protocol CLI

One core. Two ways to use it.

Most of Agio is a Go module other NSGo apps build their development environments on. The rest is an app that shows what it can do.

Library

The agent core of NSGo apps

Bring the agents you use into your own app: drivers, a host, a wire protocol and ready views behind one neutral API, with screens for phones and desktops and agents on every desktop system.

Build with it

App

Agio, the app

The same core in a window of its own: a demo of what Agio does, a place to test it, and a simple tool for working with agents. Released on GitHub, and it updates itself.

Download

Agio, the app.

Start a task, pick the project and the model, and follow the agent as it works. Everything here comes from the library; the app adds the rest of a desktop tool.

New task asks which project to work in.

Tasks, not chats

New task asks which project to work in. Running tasks lead the sidebar, the rest follow by when they were last active, and all of them come back after a restart.

The agents you already have

Agio finds the agent CLIs on your login shell’s PATH and runs them with your own sign-ins. Turn agents and models on and off in the settings.

Your project, one click away

The title bar opens a task’s folder in Finder, your terminal, your editor or your Git client.

Made to look like yours

Color schemes for light and dark over a translucent window, an optional grain, in English or Chinese.

It tells you when it’s done

A sound and a notification when an agent stops, and the computer kept awake while agents work.

Up to date by itself

Signed releases on GitHub. Agio installs them in place on macOS and Windows, and opens the release on Linux.

The parts between a CLI and your window.

Drivers translate, a host folds, and a view shows. Each layer only knows the one below it.

Four drivers, one vocabulary

Each agent speaks its own protocol. Agio turns them into the same events, turns and statuses; nothing above the drivers knows which one runs.

Turns you can read

Thinking, tool calls, streamed markdown and the time a turn took fold into a conversation. A running turn stays open; a finished one steps aside.

Here, or across the wire

host.Host runs agents on macOS, Windows or Linux. wire serves the same backend over TCP, a pipe or SSH, so a phone can show the agents a computer runs.

Views for phones and desktops

chatview.App brings tasks, a sidebar, a composer, model and reasoning choices, settings and each account’s limits, built with NSGo.

A server without a UI

Everything below chatview is headless. A server builds without NSGo, and views reach agents only through agio.Backend.

Nothing kept behind your back

Agio persists nothing; your app keeps a conversation’s cursor, folder and model. Keep a server private and give it a token.

A transcript, not a log.

Open a finished turn and read what happened: the reasoning, the files it opened, the commands it ran, the answer that streamed in.

Worked for 4s, opened: thinking, an edit and a command, then the answer.

One contract. Two places to run.

A view shows an agio.Backend. A host is one; a wire client is another. Swap it, and the same window shows local or remote agents.

host.Host starts the agent CLIs on this machine and hands their conversations straight to the view.

go tool nsgo dev cmd/agio
main.go
h := host.New(host.Options{Dir: workDir})

nsgo.Run(func(cx *core.Scope) core.Node {
	return chatview.App{Model: chatview.Bind(cx, h)}
}, nsgo.WindowSize(1040, 720))

h.Close()

Read the architecture

Built for the wire.

Remote conversations should read live and cost little.

30/s

Published, not pushed

A served session coalesces changes and publishes at most about 30 times a second, so a reply reads live without flooding a slow link.

patches

Only what changed

Turns travel as transcript patches. Streamed text sends only what arrived, not the whole conversation again.

groups

Only its own processes

Agents start in their own process group. Stopping one stops what it started, and a host signals only what it launched.

Build your own on Agio.

Install the module, pick where agents run, and hand the backend to a view.

go get github.com/oneo-me/nsgo-agio

Needs Go 1.27 and the agent CLIs you want on the login shell’s PATH. They run with your own sign-ins.

Download Agio.

For macOS, Windows and Linux, on arm64 and x64. Agio checks GitHub for new releases and updates itself.

  • macOS
  • Windows
  • Linux

Agio runs the agent CLIs on your login shell’s PATH with your own sign-ins. It sends anonymous usage statistics, never prompts or folders, and its settings turn them off.

Built with NSGo

Agio’s views are NSGo components: native Go UI for phones and desktops, written once and shown in English and Chinese. The core below them is plain, headless Go.