Zyris
zyris protocolAgent-Device Communication Protocol

An Agent With Hands on Your Machine

Zyris is an expandable protocol. A node dials a server over one websocket and announces typed capabilities—terminal, files, input, screen, browser—as tools. Attacca is the reference deployment, calling those tools straight from an agent.

Build a nodezyris-protocol on GitHub
WebSocket · hello
{
  "kind": "hello",
  "protocol": { "major": 1, "minors_supported": [0] },
  "capabilities": ["terminal", "file_io", "screen_capture"]
}

How It Works

From an Agent Stuck in Chat to a Protocol for Devices

An Agent Only Lived in Text

However smart the agent, all it could do was answer. Opening a terminal, editing a file, watching the screen, moving the mouse — that was still on you. We needed an agent that could reach into the device directly.

So We Built a Protocol

A Zyris node dials a server over one websocket and announces its capabilities. The protocol is direction-symmetric — once the handshake is done there's no client or server, either peer can call the other, open streams, or change what it offers mid-session. Terminal, screen, whatever a node announces becomes a tool an agent can call — immediately.

Meeting Attacca

This protocol met Attacca as its reference deployment. The tools a node announces become tools an agent can call directly, and the server announces attacca_api back so the node can drive agent sessions itself.

  • Terminal
  • File I/O
  • Input Control
  • Screen Capture
  • Browser Control
  • Custom Capability

Out-of-the-Box Tools

Standard Capability Catalogue

terminal, file_io, input, screen_capture, browser_chrome — the standard capabilities ship ready to use, so an agent can run commands, touch files, and see and control the screen from day one.

Device-Grant Auth

Safe Device Enrollment

Run a node and it prints an 8-character code. Enter that in Attacca and approve only the scopes you want — no secret ever has to travel between machines.

Two-Way Calls

A Direction-Symmetric Protocol

Once the handshake is done, there's no client or server. A node announces its tools while also consuming the attacca_api the server announces back — able to drive agent sessions itself.

Build a Node

One dependency, one trait, and your agent has a new tool

Zyris ships as a Rust library. Put #[zyris::capability] on a trait and the macro generates the descriptor, a server wrapper and a client — and doc comments become the tool descriptions a model reads.

  1. 01

    Add the dependency

    Take it by git until the next crates.io release. enroll adds the 8-character-code flow that issues a credential.

    Cargo.toml
    [dependencies]
zyris = { git = "https://github.com/attacca-cc/zyris-protocol", features = ["enroll"] }
  2. 02

    Declare a capability

    One trait is one set of tools. Give it a name and a version, and write the doc comments for the model that will read them.

    src/hello.rs
    #[zyris::capability(name = "hello", version = 1)]
pub trait Hello {
    /// Return a random friendly greeting, optionally addressed to `name`.
    async fn greet(&self, name: Option<String>) -> zyris::Result<Greeting>;
}
  3. 03

    Connect the node

    Build a node, put the capability on it and connect. connect keeps the link up across drops.

    src/main.rs
    let link = Node::builder()
    .name("my-node")
    .kind(NodeKind::Service)
    .capability(HelloServer(HelloWorld))
    .build()?
    .connect(zyris::DEFAULT_SERVER_URL, std::env::var("ZYRIS_CREDENTIAL")?)
    .await?;

link.wait_closed().await?;

Run one now

$cargo run -p zyris --example hello --features enroll

With nothing configured it enrols against attacca.cc and prints an 8-character code. Type it into Attacca on any device with a browser, ask an agent to call hello.greet, and the node answers "Hello World".

The crates

zyris
The whole stack behind one name. Depend on this one.
zyris-core
The node runtime — connection state machine, transports, announce/accept, reconnect, enrolment.
zyris-proto
Wire types only: envelopes, frames, the handshake. No I/O, no async.
zyris-caps
The standard catalogue — terminal, file_io, input, screen_capture, browser_chrome, file_transfer.
zyris-fs · zyris-terminal
Reference file_io and terminal. Pure Rust.
zyris-screen · zyris-input
Reference screen capture, and keyboard and pointer input.
zyris-transfer · zyris-p2p
Node-to-node file transfer, and the transport that connects nodes directly.
zyris-attacca
attacca_api, announced by the server — so a node can drive agents and sessions itself.
Read the docsRead the protocol speczyris-hello reference node

Use Cases

What You Can Build With Zyris

From terminal to screen, input, and browser — see what an agent can actually do with just the standard capabilities.

Terminal Automation

An agent runs shell commands through a node's terminal capability — builds, deploys, and scripts, right on your machine.

  • Ready to use via the standard terminal capability
  • Agent runs shell commands directly
  • Output and exit codes come straight back
  • Long-running jobs stream as they go

An Agent That Sees the Screen and Drives Input

screen_capture hands the agent a look at your screen; the input capability lets it move the mouse and type — GUI automation and desktop tasks, done for you.

  • Live screen capture via screen_capture
  • Mouse and keyboard control via the input capability
  • Automates GUI-only apps too
  • Only ever acts within the scopes you approved

Driving a Real Browser

The browser_chrome capability opens a real Chrome window, fills forms, and clicks — handling web-based workflows end to end.

  • Controls a real Chrome instance via browser_chrome
  • Fills forms, clicks, and scrapes
  • Reuses your existing login session
  • Automates web-based workflows

Products

Built on Zyris

You do not have to build a node yourself. Desktop, terminal or server — pick the one that fits what you want to connect.

zyris

The desktop app that keeps your computer connected to Attacca

Sits in the tray and hands your agents this machine's shell, files, keyboard, mouse and screen — plus the local MCP servers you already run. For Windows and Linux.

Learn more

zyris code

A coding agent, straight from the terminal

One line to install. Builds for Windows, Linux and macOS — the agent runs on Attacca, the tools run on your machine.

Learn more

zyris docker

A container node that puts Docker and Kubernetes servers on Attacca

Watches system, Docker and Kubernetes state from inside a container, and when something it guards goes down, calls in an agent to diagnose and fix it.

Learn more