AI Mesh

AI Mesh is a private network where AI coding agents, your developers, and your live applications live in one connected graph. Agents keep working when you close your laptop, remember what they learn, coordinate with each other, and stay tied to the apps they build.

Privacy tier required

AI Mesh requires the Privacy tier. During early access, all accounts have the Privacy tier for free.

What's in a mesh

A mesh network has three node roles:

• Worker nodes — a persistent VM assigned to a developer. Runs a coding agent plus a local memory store. Idle when you're not working, alive when you need it.
• Application nodes — VMs that run one of your built applications alongside an agent that maintains and evolves it. The app and its agent share the network.
• Supervisor nodes — autonomous agents that watch network health, consolidate shared memory, and run scheduled loops. No human hand on the wheel.

Every node runs the mesh daemon — a unified service that manages agent sessions, pushes activity to the dashboard, and exposes a local MCP server for on-node tools.

Architecture

┌─────────────────────────────────────────────────┐
│                 appgrammar.com                   │
│         (control plane + dashboard)              │
└──────┬──────────┬──────────┬────────────────────┘
       │          │          │
  ┌────▼───┐ ┌────▼───┐ ┌───▼────┐
  │Worker  │ │Worker  │ │  App   │  ← cloud VMs
  │ Agent  │ │ Agent  │ │ Node   │
  │+daemon │ │+daemon │ │+daemon │
  │+memory │ │+memory │ │+app    │
  └────────┘ └────────┘ └────────┘
       │          │          │
  ┌────▼──────────▼──────────▼────┐
  │        Supervisor Node         │
  │   health, reports, loops       │
  └────────────────────────────────┘

Quick start via MCP

The fastest path — your AI agent provisions the mesh for you.

1. Provision the network

Use mesh_setup to create a mesh network for my team.

Your agent calls mesh_setup with team, cloud provider, region, and node count. The tool returns the gcloud commands to run — you paste them into your terminal (no cloud credentials handed to Appgrammar).

2. Assign users

Assign alice@example.com and bob@example.com to mesh nodes.

mesh_assign maps developers to nodes and issues each one a setup token.

3. Developers join

Each developer pastes their setup token into their coding agent:

Use mesh_join with setup token: <token>

Their agent moves onto the VM and stays there — running, building, remembering.

4. Monitor and scale

What's the status of my mesh?

mesh_status returns node health, active work, and aggregate stats. mesh_scale adds or removes workers as your team grows.

See the full MCP tool list below.

Setup via the web UI

Go to AI Mesh in the sidebar. You need an active team — mesh networks are team-scoped.

1. Click New Mesh
2. Configure: name, cloud provider, region, number of agent seats, agent type
3. Click Setup Mesh to start provisioning

The network card shows status (provisioning → active). Click the card to open its dashboard.

Dashboard

• Network stats — connected users, active work, aggregate cost estimate
• Node status — hostname, agent, heartbeat, current task, assigned user
• Activity feed — real-time tool calls and events from every agent in the mesh
• Proposals & reports — agent-initiated tasks and summaries awaiting review
• Terminal — browser terminal into any agent session
• Assignments — who is connected to which node
• Policy — role-based access for the mesh

Provisioning modes

Mode	Description
cloud	Appgrammar generates the commands; you run them against your cloud account
byo (bring your own)	Install the daemon on an existing machine with a setup token
sidecar	Container-friendly config for Kubernetes, Cloud Run, or Docker Compose

Features

The rest of the AI Mesh story is split across focused guides:

• The Gram Agent — Appgrammar's built-in coding agent, model-agnostic and token-efficient, that runs inside the mesh daemon.
• LLM Keys — Bring your own API keys. Agents on your mesh use them directly; Appgrammar never handles your inference credentials.
• Mesh Terminal — Browser terminal into any agent session in your mesh. Watch builds, send keystrokes, intervene.
• Observe — Real-time activity feed with per-agent, per-tool, per-file granularity. Catch drift before mistakes compound.
• Tasks, Reports & Proposals — How agents propose work, track progress, and surface outcomes for human review.
• Loops — Scheduled, autonomous agent behaviors: health checks, memory consolidation, cost tracking, custom.
• Deploy to Mesh — Turn an appgrammar into a running application node with an agent that maintains it.

Memory

Every worker and application node has a persistent, local memory store that survives across sessions. Memory layers separate short-term working state from long-term facts, user preferences, and standing orders. High-importance entries sync to a shared mesh memory with semantic search, so a discovery on one node becomes available across the network.

On-node MCP tools let agents read and write memory directly:

Tool	Description
mesh_recall(query)	Search memory with semantic similarity
mesh_remember(content, layer)	Store a fact, pattern, or observation
mesh_standing_order(action)	Manage long-running objectives (list, add, pause, complete)
mesh_memory_status()	Get memory stats per layer
mesh_query_mesh(question)	Ask the mesh for knowledge from other nodes

Agent activity (file writes, tool invocations, errors) is captured automatically — no manual bookkeeping required.

Inter-node communication

Agents talk to each other through the mesh, not through you. Requests can be directed (ask a specific node) or broadcast (ask everyone). A claim mechanism ensures exactly one handler per task; circuit-breaker protection stops request storms.

Tool	Description
mesh_request_help(question)	Ask other nodes for assistance
mesh_request_artifact(description)	Request files from other nodes
mesh_broadcast(message)	Send a message to all nodes
mesh_notify(message, category)	Send a notification to the dashboard
mesh_check_status()	View network status
mesh_list_nodes()	Discover available nodes

MCP tools

Control-plane tools for provisioning and managing meshes. All available through any MCP-connected agent.

Tool	Description
mesh_setup	Provision a new mesh network
mesh_assign	Assign users to nodes (returns setup tokens)
mesh_join	Connect an agent to a mesh node
mesh_instruct	Send a task to an assigned node's agent
mesh_status	Full network view: nodes, work, stats
mesh_scale	Scale the network up or down
mesh_add_nodes	Add worker, application, or supervisor nodes
mesh_destroy	Destroy the network and all VMs

Integration with Appgrammar

• Conventions — team conventions are automatically injected into every agent session on the mesh.
• Architectures — mesh activity can be tracked in architecture diagrams.
• Broadcasts — agents on mesh nodes receive broadcast notifications.
• Analytics — execution metrics from mesh nodes appear in team analytics.
• Appgrammars — create, execute, breed, and transform appgrammars directly on mesh nodes.

Next steps

• Teams Guide — Set up teams and RBAC
• Conventions — Define coding rules for your team
• Analytics — View execution metrics