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 itAgio 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
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
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 itApp
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.
DownloadStart 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. Running tasks lead the sidebar, the rest follow by when they were last active, and all of them come back after a restart.
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.
The title bar opens a task’s folder in Finder, your terminal, your editor or your Git client.
Color schemes for light and dark over a translucent window, an optional grain, in English or Chinese.
A sound and a notification when an agent stops, and the computer kept awake while agents work.
Signed releases on GitHub. Agio installs them in place on macOS and Windows, and opens the release on Linux.
Drivers translate, a host folds, and a view shows. Each layer only knows the one below it.
Each agent speaks its own protocol. Agio turns them into the same events, turns and statuses; nothing above the drivers knows which one runs.
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.
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.
chatview.App brings tasks, a sidebar, a composer, model and reasoning choices, settings and each account’s limits, built with NSGo.
Everything below chatview is headless. A server builds without NSGo, and views reach agents only through agio.Backend.
Agio persists nothing; your app keeps a conversation’s cursor, folder and model. Keep a server private and give it a token.
Open a finished turn and read what happened: the reasoning, the files it opened, the commands it ran, the answer that streamed in.
Thinking
Reasoning stays a step, not a wall of text.
Tools
Each call keeps its target and its output.
Answer
The reply streams in as markdown.
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/agioh := 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()wire serves the same host over TCP with a token. It builds without NSGo, so it runs anywhere Go does.
go run ./examples/server -token secreth := host.New(host.Options{Dir: workDir})
defer h.Close()
log.Fatal(wire.ListenAndServe(h, "127.0.0.1:7788", token))wire.Client is a backend too. Hand it to the same chatview.App and the agents run somewhere else.
AGIO_TOKEN=secret go tool nsgo dev examples/clientc, err := wire.Dial("127.0.0.1:7788", token)
if err != nil {
log.Fatal(err)
}
defer c.Close()
nsgo.Run(func(cx *core.Scope) core.Node {
return chatview.App{Model: chatview.Bind(cx, c)}
})Remote conversations should read live and cost little.
30/s
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
Turns travel as transcript patches. Streamed text sends only what arrived, not the whole conversation again.
groups
Agents start in their own process group. Stopping one stops what it started, and a host signals only what it launched.
Install the module, pick where agents run, and hand the backend to a view.
go get github.com/oneo-me/nsgo-agioNeeds Go 1.27 and the agent CLIs you want on the login shell’s PATH. They run with your own sign-ins.
For macOS, Windows and Linux, on arm64 and x64. Agio checks GitHub for new releases and updates itself.
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.
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.