TailMesh, four protocol videos, and the audit trail that ties it together

A network mesh plugin that manages itself, a video series that explains the protocol stack, and an audit trail that now covers every operation the collector touches.

TailMesh: network mesh as a plugin

TailMesh is a QuoxCORE plugin that connects to your Tailscale network and gives you a dashboard, a connector, webhooks, and its own specialist agent: MESHNET.

The plugin started as "Tailscale Mesh" and was renamed to TailMesh during development. The rename is cosmetic. The architecture is not.

MESHNET is the third specialist agent to ship inside a plugin this week, after FORGE (GitHub) and KEEPER (system maintenance). The pattern is consistent: plugin declares an agent in its manifest, agent registers in the sidebar, agent gets its own MCP tools, agent is governed by AOCL policy. The infrastructure does not care whether the plugin was built by us or a third-party developer. The interfaces are the same.

The credential flow deserves a mention. TailMesh uses a vault-only approach: the API key goes into the encrypted credential vault during setup and never surfaces again. The connector resolves credentials by ID at call time, decrypts them server-side, and uses them for the API request. The browser never sees the key.

Multi-field credential resolution was fixed during development to support connectors like Tailscale that need both an API key and an organisation identifier.

Four protocol explainer videos

Writing protocol specs is one thing. Explaining them to someone who has not read the spec is another. This week, four explainer videos were produced and embedded in the documentation:

Each video is embedded on its respective documentation page. The AOCL Compliance Suite and AOCL Developer Kit also got their own explainer videos on their product pages. A Decision Evidence explainer was added to the product page as well.

The videos are not marketing material. They are technical walkthroughs aimed at developers and architects who need to understand the protocol stack without reading the specifications end to end. Each one runs through the core concepts, shows where the protocol fits in the stack, and explains the data structures involved.

AEE audit trail: every collector operation, recorded

The most significant change this week is not a plugin or a video. It is the AEE audit trail being wired into every operation the collector performs.

Previously, AEE envelopes were generated for specific operations: chat interactions, tool executions, policy decisions. Now, every collector operation produces an envelope. API calls, credential resolutions, file operations, agent delegations, provider key lookups. All of them.

What the audit trail captures:

• Chat message processing
• Tool execution (MCP)
• Credential vault access
• Agent delegation events
• Provider key resolution
• File read/write operations
• Policy evaluation results
• Error and recovery events

This is the difference between having a protocol and using it. AEE envelopes have been part of QuoxCORE since the protocol was drafted. But coverage was selective. Expanding to every collector operation means the audit trail is now complete. If the collector did it, there is an envelope.

For compliance-sensitive deployments, this is the capability that matters. An auditor can trace any operation back to its envelope, see the intent, the action, the outcome, and the agent that performed it: this is the audit trail, from the auditor's side. The trail is not a log file. It is a structured, queryable, envelope-based record that follows the AEE specification.

How these connect

TailMesh, the protocol videos, and the audit trail look like three separate things. They are not.

TailMesh is a plugin that brings a specialist agent. That agent uses MCP tools to interact with an external service. Every tool call generates an AEE envelope. The governance layer (AOCL) determines what the agent is permitted to do. The evidence chain (VOLT) records the hash-chained sequence. And now there is a video that explains each of those layers to someone who has never read the spec.

That is the stack working end to end. Not as a diagram. As running code, with a plugin anyone could have built, governed by protocols anyone can read, recorded in an audit trail that covers everything.

Quox (quox.ai) builds trust infrastructure for AI agent operations. Its open protocols, AEE for standardised agent messaging, AOCL for orchestration control and observability, and VOLT for cryptographic evidence chains, provide the accountability architecture that autonomous systems require. Four open protocol specifications. Building in the UK.