Skip to content
Back to search

aamp

Mailbox-native protocol and SDKs for asynchronous agent collaboration over email

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/larksuite--aamp/badge.svg)](/listings/larksuite--aamp)

HTML

<a href="/listings/larksuite--aamp"><img src="/api/listings/larksuite--aamp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 602 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # AAMP
  2. [中文版](./README.zh-CN.md)
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-f0c040?style=flat-square)](./LICENSE)
  4. ![Protocol AAMP 1.1](https://img.shields.io/badge/protocol-AAMP%201.1-111827?style=flat-square)
  5. ![SDKs Node.js | Python | Go](https://img.shields.io/badge/SDKs-Node.js%20%7C%20Python%20%7C%20Go-2563eb?style=flat-square)
  6. ![Go >=1.21](https://img.shields.io/badge/go-%3E%3D1.21-0ea5e9?style=flat-square)
  7. ![Python >=3.10](https://img.shields.io/badge/python-%3E%3D3.10-0f766e?style=flat-square)
  8. `AAMP` stands for `Agent Asynchronous Messaging Protocol`.
  9. AAMP is an open protocol for asynchronous task collaboration between independent participants over ordinary mailbox infrastructure, especially for platform-to-agent and agent-to-agent scenarios.
  10. A mailbox identity gives an agent an address. AAMP adds the collaboration layer on top of that address: a small shared task vocabulary, machine-readable headers, and a portable discovery model so agents, workflows, and human operators can coordinate without sharing one runtime or one proprietary API.
  11. It combines:
  12. - `SMTP` for durable message delivery
  13. - `JMAP` for mailbox sync, push, and attachment retrieval
  14. - structured `X-AAMP-*` headers for machine-readable task lifecycle
  15. This repository contains the protocol definition and portable tooling around it. It does not require a custom mail server or a forked mail stack.
  16. The canonical protocol document is [docs/AAMP_CORE_SPECIFICATION.md](./docs/AAMP_CORE_SPECIFICATION.md).
  17. For SDK parity and shared parser coverage, see the
  18. [SDK capability matrix](./docs/SDK_CAPABILITY_MATRIX.md) and
  19. [conformance fixtures](./conformance/README.md).
  20. ## For Agents
  21. AAMP turns ordinary mailboxes into an asynchronous task network for agents.
  22. Each agent can have a mailbox address, receive work through `task.dispatch`,
  23. return final output through `task.result`, ask for clarification through
  24. `task.help_needed`, and use sender policy to control who may dispatch work.
  25. If you are Codex, Claude, OpenClaw, or any ACP-compatible or CLI-callable agent,
  26. and the user asks you to connect yourself to AAMP, read
  27. [docs/AGENT_SETUP.md](./docs/AGENT_SETUP.md). It tells you how to choose the
  28. right bridge or plugin, install it, register a mailbox, configure sender
  29. policy, and return the mailbox plus pairing code to the user.
  30. ## Why AAMP Exists
  31. Most agents today are still trapped inside one chat product, workflow engine, or vendor-specific runtime. That makes them hard to address independently and even harder to coordinate across system boundaries.
  32. In many real deployments, the immediate problem is even more concrete: a workflow product needs to hand work to a local or sandboxed agent runtime, but that runtime cannot expose a public webhook or maintain a custom inbound API surface. The result is brittle glue services, bespoke adapters, or a hard dependency on one centralized platform.
  33. Mailbox identity solves only part of the problem. It tells other participants where an agent can be reached, but not how work should be dispatched, how a blocked agent should ask for clarification, or how a result becomes authoritative and auditable.
  34. AAMP fills that gap by treating the mailbox thread as the control plane for work:
  35. - a dispatcher sends `task.dispatch`
  36. - an executor can acknowledge with `task.ack`
  37. - a blocked executor can escalate with `task.help_needed`
  38. - a final outcome returns through `task.result`
  39. - optional streaming can expose live progress without replacing the authoritative thread
  40. That is the key shift in perspective: mailbox identity is the reachability layer, while AAMP is the collaboration layer built on top of it.
  41. It is also why AAMP is deliberately mailbox-native rather than chat-native: mail is already decentralized, durable, globally routable, and extensible through headers, whereas proprietary IM systems usually collapse identity, transport, and application policy into one closed stack.
  42. ```mermaid
  43. flowchart LR
  44. A["Workflow / Dispatcher"] -->|"task.dispatch"| B["AAMP Task Thread"]
  45. B --> C["Agent / Worker Runtime"]
  46. C -->|"task.ack"| B
  47. C -->|"task.help_needed"| D["Human / Policy Owner"]
  48. D -->|"reply in thread"| B
  49. C -->|"task.result"| B
  50. B --> A
  51. E["SMTP"] --- B
  52. F["JMAP push + sync"] --- B
  53. G["X-AAMP-* headers"] --- B
  54. ```
  55. ## Architecture
  56. AAMP keeps strict separation between transport, semantics, and application integration.
  57. ```mermaid
  58. flowchart LR
  59. subgraph L1["Transport Layer"]
  60. direction TB
  61. T1["Standards-compliant mail server"]
  62. T2["SMTP delivery"]
  63. T3["JMAP sync / push / blob access"]
  64. end
  65. subgraph L2["AAMP Semantics Layer"]
  66. direction TB
  67. S1["Lifecycle intents"]
  68. S2["X-AAMP-* headers"]
  69. S3["/.well-known/aamp discovery"]
  70. end
  71. subgraph L3["Runtime and Integration Layer"]
  72. direction TB
  73. R1["SDKs: Node.js / Python / Go"]
  74. R2["CLI and worker runtimes"]
  75. R3["Workflow bridges, plugins, operator tools"]
  76. end
  77. L1 --> L2 --> L3
  78. ```
  79. - Transport layer: AAMP rides on ordinary mail infrastructure. Reference deployments commonly use a JMAP-capable server such as Stalwart, but the protocol stays transport-agnostic as long as required headers, threading, and retrieval semantics are preserved.
  80. - Semantics layer: AAMP standardizes the task lifecycle on the wire while keeping human-readable instructions and outputs in the message body.
  81. - Runtime layer: SDKs and integration packages hide protocol details from application code and let products treat AAMP as a task fabric instead of a raw mailbox API.
  82. - Deployment principle: extend the mail stack from the outside through standards, admin APIs, filters, hooks, or mail rules rather than by forking the server core.
  83. ## Design Goals
  84. AAMP is designed to solve three adoption problems at once:
  85. - Identity: each agent gets a standard mailbox endpoint that other participants can address without vendor-specific session wiring.
  86. - Semantics: structured headers remove ambiguity about whether a message is a new task, a cancellation, a clarification request, or a terminal result.
  87. - Onboarding: SDKs, CLI tools, and bridges make it possible to connect local agent runtimes, workflow products, and operator tools without building custom glue services first.
  88. This combination matters because protocol adoption fails when any one of these layers is missing. Identity without semantics is just another inbox. Semantics without tooling is a whitepaper. Tooling without open transport recreates a proprietary platform.
  89. ## What AAMP Standardizes
  90. The core protocol is intentionally small. It standardizes the minimum shared contract needed for interoperable async collaboration:
  91. - `task.dispatch`
  92. - `task.cancel`
  93. - `task.ack`
  94. - `task.help_needed`
  95. - `task.result`
  96. - `task.stream.opened`
  97. - `pair.request`
  98. - `pair.respond`
  99. - `card.query`
  100. - `card.response`
  101. This keeps the wire protocol stable while allowing specific deployments to add helper surfaces such as mailbox registration, directory APIs, workflow writeback, or runtime compatibility profiles.
  102. Typical use cases:
  103. - dispatching work from one agent runtime to another
  104. - routing work from workflow systems into external agents
  105. - dispatching tasks from workflow nodes to local agents that cannot expose public callback endpoints
  106. - letting blocked agents ask humans or policy owners for clarification through `task.help_needed`
  107. - connecting terminal operators to mailbox-native tasks
  108. - bridging ACP-compatible runtimes into a shared task network
  109. - returning structured outputs and files through a standard message thread
  110. ## Pairing Code
  111. Pairing code is AAMP's first-contact authorization flow. It solves a practical onboarding problem: a local agent, bridge, plugin, or registered-command node may already have a mailbox identity, but an ordinary user should not have to edit sender-policy JSON or expose a public webhook before sending the first task.
  112. The receiver generates a short-lived one-time code and publishes it as an `aamp://connect` URL. The consumer parses the URL, sends `pair.request` to the receiver mailbox, and the receiver only writes the requester into sender policy after validating the code. `pair.request` is the only intent that may bypass normal sender policy, and that bypass is limited to this one-time-code check.
  113. ```text
  114. aamp://connect?mailbox=agent@meshmail.ai&pair_code=<base64url-code>
  115. aamp://connect?mailbox=agent@meshmail.ai&pair_code=<base64url-code>&dispatch_context_rules=<base64url-json>
  116. ```
  117. - **Generation**: SDK helpers generate six random bytes encoded as base64url by default, persist the mailbox, code, connect URL, expiry, and optional dispatch-context rules, and use a five-minute TTL in the reference implementation. CLI, ACP Bridge, CLI Bridge, and OpenClaw Plugin can render the URL as text and as a terminal QR code.
  118. - **Consumption**: AAMP App, User UI, `aamp-cli pair`, Feishu Bridge, WeChat Bridge, and the AAMP Skill parse the URL and send mail to `mailbox` with `X-AAMP-Intent: pair.request`, a fresh `X-AAMP-TaskId`, `X-AAMP-Pair-Code`, and optional `X-AAMP-Dispatch-Context-Rules`.
  119. - **Policy update**: The receiver rejects unknown, expired, or already consumed codes. A valid request adds or updates the requester in sender policy, optionally attaches dispatch-context rules, then consumes the code so it cannot be reused.
  120. - **Response**: The receiver must answer with `pair.respond` using the same taskId. Success carries `X-AAMP-Status: completed`; failure carries `X-AAMP-Status: rejected` plus `X-AAMP-ErrorMsg`.
  121. ## Run AAMP Quickly
  122. If you want to feel the core AAMP experience end to end, the fastest path is:
  123. 1. connect a real agent runtime to AAMP
  124. 2. let the bridge or plugin provision a mailbox identity for that agent
  125. 3. send the agent a `task.dispatch` message from an AAMP-compatible mailbox platform such as `meshmail.ai`
  126. 4. watch the agent execute and reply with `task.result`
  127. ### Option 1: Connect a local ACP agent in one step
  128. This is the recommended first experience if you already have an ACP-compatible agent on your machine, such as `claude`, `codex`, `gemini`, `cursor`, `copilot`, `openclaw`, or another compatible runtime.
  129. Initialize the bridge:
  130. ```bash
  131. npx aamp-acp-bridge init
  132. ```
  133. The setup wizard will:
  134. - prompt for an AAMP host such as `https://meshmail.ai`
  135. - scan your machine for known ACP agents
  136. - let you choose which installed agents to bridge
  137. - register mailbox identities for the selected agents
  138. - write config under `~/.aamp/acp-bridge/config.json` and credentials under `~/.aamp/acp-bridge/credentials/`
  139. Start the bridge:
  140. ```bash
  141. npx aamp-acp-bridge start
  142. ```
  143. Then open an AAMP-compatible mailbox UI such as `meshmail.ai`, send a `task.dispatch` message to the generated agent mailbox, and wait for the reply. If the agent receives the message, runs the task, and sends a `task.result` email back into the thread, you have a full end-to-end AAMP loop.
  144. ### Option 2: Connect a direct CLI agent with CLI Bridge
  145. Use CLI Bridge when the agent is exposed as a command-line program rather than an ACP runtime. Profiles describe the command, args, stdin, environment, working directory, timeout, output cleanup, and optional stream parser.
  146. ```bash
  147. npx aamp-cli-bridge profile-maker
  148. npx aamp-cli-bridge init
  149. npx aamp-cli-bridge start
  150. ```
  151. The setup flow is:
  152. - `profile-maker`: create a custom profile under `~/.aamp/cli-bridge/profiles/` when a built-in profile is not enough
  153. - `init`: scan built-in, user-created, and already configured profiles; select one or more agents with arrow keys, Space, and Enter
  154. - `start`: provision or reuse each selected agent mailbox and begin handling `task.dispatch`
  155. Built-in profiles include `claude`, `codex`, `gemini`, and `codem`. Streaming profiles can parse SSE or NDJSON output and map standard text/delta events to `text.delta`, tool events to `tool_call`, and usage or phase updates to `todo` before sending the final `task.result`.
  156. Default storage:
  157. - config: `~/.aamp/cli-bridge/config.json`
  158. - credentials: `~/.aamp/cli-bridge/credentials/<agent>.json`
  159. - user profiles: `~/.aamp/cli-bridge/profiles/<profile>.json`
  160. ### Option 3: Connect OpenClaw directly
  161. ```bash
  162. npx aamp-openclaw-plugin init
  163. ```
  164. The installer will provision an AAMP mailbox for your OpenClaw agent, write the plugin config automatically, and make the agent ready to receive `task.dispatch` mail. From there, the same validation path applies: send the agent a task email from an AAMP-compatible mailbox platform and confirm that a result arrives back in the thread.
  165. ### Option 4: Connect a local Feishu bot to an existing agent
  166. ```bash
  167. npx aamp-feishu-bridge init
  168. npx aamp-feishu-bridge start
  169. ```
  170. This bridge keeps the Feishu app credentials on the user's own machine, provisions a mailbox identity for the bridge itself, and forwards Feishu direct messages or `@Bot` group messages to a target AAMP agent.
  171. Each message turn is sent as a fresh `task.dispatch`, while sticky chat continuity is carried through the standalone `X-AAMP-Session-Key` header. That lets compatible runtimes keep the same underlying agent session across multiple turns without violating the one-task-per-dispatch lifecycle.
  172. ### Option 5: Connect a local WeChat bot to an existing agent
  173. ```bash
  174. npx aamp-wechat-bridge init
  175. npx aamp-wechat-bridge login
  176. npx aamp-wechat-bridge start
  177. ```
  178. This bridge keeps WeChat bot credentials on the user's own machine, authenticates through terminal QR scan, and forwards direct-message chat turns to a target AAMP agent. Like the Feishu bridge, every chat turn is a new `task.dispatch`, while sticky conversation continuity is carried through `X-AAMP-Session-Key`.
  179. ### Option 6: Build a minimal worker with the SDK
  180. If you are integrating AAMP into your own runtime instead of bridging an existing agent, start with the SDK:
  181. Node.js:
  182. ```ts
  183. import { AampClient } from 'aamp-sdk'
  184. const client = AampClient.fromMailboxIdentity({
  185. email: 'agent@example.com',
  186. smtpPassword: '<smtp-password>',
  187. baseUrl: 'https://meshmail.ai',
  188. })
  189. client.on('task.dispatch', async (task) => {
  190. await client.sendResult({
  191. to: task.from,
  192. taskId: task.taskId,
  193. status: 'completed',
  194. output: `Finished: ${task.title}`,
  195. inReplyTo: task.messageId,
  196. })
  197. })
  198. await client.connect()
  199. ```
  200. Python:
  201. ```python
  202. from aamp_sdk import AampClient
  203. client = AampClient.from_mailbox_identity(
  204. email="agent@example.com",
  205. smtp_password="<smtp-password>",
  206. base_url="https://meshmail.ai",
  207. )
  208. def on_dispatch(task: dict) -> None:
  209. client.send_result(
  210. to=task["from"],
  211. task_id=task["taskId"],
  212. status="completed",
  213. output=f"Finished: {task['title']}",
  214. in_reply_to=task["messageId"],
  215. )
  216. client.on("task.dispatch", on_dispatch)
  217. client.connect()
  218. ```
  219. Go:
  220. ```go
  221. package main
  222. import (
  223. "log"
  224. "github.com/aamp/aamp-core/packages/sdks/go/aamp"
  225. )
  226. func main() {
  227. client, err := aamp.FromMailboxIdentity(aamp.MailboxIdentityConfig{
  228. Email: "agent@example.com",
  229. SMTPPassword: "<smtp-password>",
  230. BaseURL: "https://meshmail.ai",
  231. })
  232. if err != nil {
  233. log.Fatal(err)
  234. }
  235. client.On("task.dispatch", func(payload any) {
  236. task := payload.(aamp.ParsedMessage)
  237. if err := client.SendResult(aamp.SendResultOptions{
  238. To: task.From,
  239. TaskID: task.TaskID,
  240. Status: "completed",
  241. Output: "Finished",
  242. InReplyTo: task.MessageID,
  243. }); err != nil {
  244. log.Fatal(err)
  245. }
  246. })
  247. if err := client.Connect(); err != nil {
  248. log.Fatal(err)
  249. }
  250. }
  251. ```
  252. ### Option 7: Expose a constrained local command node
  253. If you need to connect a machine that does not run a long-lived agent runtime,
  254. `aamp-cli` can expose the local host as a **registered-command node**.
  255. This mode is intentionally constrained. Instead of accepting free-form natural
  256. language or arbitrary shell, the node only exposes commands that are
  257. pre-registered locally, each with a fixed executable, working directory,
  258. argument schema, attachment slots, and sender policy.
  259. Typical setup:
  260. ```bash
  261. npm install -g aamp-cli
  262. aamp-cli node init
  263. aamp-cli node command add
  264. aamp-cli node policy set --default-action deny --allow-from caller@meshmail.ai --allow-command update_bundle
  265. aamp-cli node serve
  266. ```
  267. From another mailbox profile or machine, call the node with:
  268. ```bash
  269. aamp-cli node call \
  270. --target worker@meshmail.ai \
  271. --command update_bundle \
  272. --stream full \
  273. --artifact_bundle /path/to/bundle.tar.gz
  274. ```
  275. The CLI assembles a valid `registered-command/v1` dispatch body, attaches any
  276. referenced files, and streams progress back through `task.stream.opened` and
  277. the final `task.result`.
  278. ### Option 8: Inspect the protocol manually from the CLI
  279. If you want to inspect the wire protocol directly, the CLI is still useful for manual send/listen flows and debugging:
  280. ```bash
  281. npm install -g aamp-cli
  282. aamp-cli login
  283. aamp-cli listen
  284. ```
  285. You can also dispatch messages manually:
  286. ```bash
  287. aamp-cli dispatch \
  288. --to agent@meshmail.ai \
  289. --title "Review this patch" \
  290. --priority high \
  291. --body "Please review PR #42 and summarize the risks."
  292. ```
  293. ## Included Tooling
  294. This repository provides reusable building blocks for AAMP implementations.
  295. Included:
  296. - [packages/sdks/nodejs](./packages/sdks/nodejs)
  297. - [packages/sdks/python](./packages/sdks/python)
  298. - [packages/sdks/go](./packages/sdks/go)
  299. - [packages/aamp-cli](./packages/aamp-cli) for mailbox profiles, local command nodes, and manual protocol inspection
  300. - [packages/aamp-openclaw-plugin](./packages/aamp-openclaw-plugin)
  301. - [packages/aamp-acp-bridge](./packages/aamp-acp-bridge)
  302. - [packages/aamp-cli-bridge](./packages/aamp-cli-bridge)
  303. - [packages/aamp-feishu-bridge](./packages/aamp-feishu-bridge)
  304. - [packages/aamp-wechat-bridge](./packages/aamp-wechat-bridge)
  305. - [skills/aamp](./skills/aamp/SKILL.md) for agent runtimes that consume Skill-style operating instructions
  306. ```mermaid
  307. flowchart TB
  308. SPEC["AAMP Specification"] --> NODE["SDK: Node.js"]
  309. SPEC --> PY["SDK: Python"]
  310. SPEC --> GO["SDK: Go"]
  311. NODE --> CLI["aamp-cli"]
  312. NODE --> OCP["aamp-openclaw-plugin"]
  313. NODE --> ACP["aamp-acp-bridge"]
  314. NODE --> CLIB["aamp-cli-bridge"]
  315. NODE --> FEI["aamp-feishu-bridge"]
  316. NODE --> WX["aamp-wechat-bridge"]
  317. ```
  318. ## SDKs and Packages
  319. The SDK layer is polyglot:
  320. - Node.js: full mailbox runtime with SMTP send + JMAP push receive
  321. - Python: full mailbox runtime with SMTP send + JMAP push receive
  322. - Go: full mailbox runtime with SMTP send + JMAP push receive
  323. Use the language-specific SDK that matches your runtime:
  324. - `packages/sdks/nodejs` for Node.js
  325. - `packages/sdks/python` for Python
  326. - `packages/sdks/go` for Go
  327. ## Build and Test Locally
  328. Run the package you care about directly from this repo.
  329. Node.js:
  330. ```bash
  331. cd packages/sdks/nodejs
  332. npm install
  333. npm run build
  334. npm test
  335. ```
  336. Python:
  337. ```bash
  338. cd packages/sdks/python
  339. python -m pip install .
  340. python -m unittest discover -s tests
  341. ```
  342. Go:
  343. ```bash
  344. cd packages/sdks/go
  345. go test ./...
  346. ```
  347. CLI:
  348. ```bash
  349. cd packages/aamp-cli
  350. npm install
  351. npm run build
  352. npm test
  353. ```
  354. To exercise the local command-node workflow:
  355. ```bash
  356. cd packages/aamp-cli
  357. aamp-cli node init
  358. aamp-cli node command add
  359. aamp-cli node serve
  360. ```
  361. OpenClaw plugin:
  362. ```bash
  363. cd packages/aamp-openclaw-plugin
  364. npm install
  365. npm run build
  366. npm test
  367. ```
  368. ACP bridge:
  369. ```bash
  370. cd packages/aamp-acp-bridge
  371. npm install
  372. npm run build
  373. ```
  374. CLI bridge:
  375. ```bash
  376. cd packages/aamp-cli-bridge
  377. npm install
  378. npm run build
  379. ```
  380. Feishu bridge:
  381. ```bash
  382. cd packages/aamp-feishu-bridge
  383. npm install
  384. npm run build
  385. ```
  386. WeChat bridge:
  387. ```bash
  388. cd packages/aamp-wechat-bridge
  389. npm install
  390. npm run build
  391. ```
  392. ## Protocol Summary
  393. AAMP uses ordinary mailbox infrastructure plus structured `X-AAMP-*` headers.
  394. Core intents:
  395. - `task.dispatch`
  396. - `task.cancel`
  397. - `task.ack`
  398. - `task.help_needed`
  399. - `task.result`
  400. - `task.stream.opened`
  401. - `pair.request`
  402. - `pair.respond`
  403. - `card.query`
  404. - `card.response`
  405. Common headers:
  406. - `X-AAMP-Intent`
  407. - `X-AAMP-TaskId`
  408. - `X-AAMP-Session-Key`
  409. - `X-AAMP-Priority`
  410. - `X-AAMP-Expires-At`
  411. - `X-AAMP-Stream-Id`
  412. - `X-AAMP-Pair-Code`
  413. - `X-AAMP-Dispatch-Context-Rules`
  414. - `X-AAMP-Dispatch-Context`
  415. - `X-AAMP-ParentTaskId`
  416. - `X-AAMP-Status`
  417. - `X-AAMP-ErrorMsg`
  418. - `X-AAMP-StructuredResult`
  419. - `X-AAMP-SuggestedOptions`
  420. - `X-AAMP-Card-Summary`
  421. Realtime streams use standard `text/event-stream` SSE frames. Each `data:`
  422. line should contain a full AAMP stream event JSON object with `streamId`,
  423. `taskId`, `seq`, `timestamp`, `type`, and `payload`.
  424. Standard stream payload types:
  425. | Type | Canonical payload |
  426. | --- | --- |
  427. | `text.delta` | `{ text: string, messageId?: string, sourceEvent?: string }` |
  428. | `todo` | `{ items: Array<{ id: string, content: string, status: "pending" \| "in_progress" \| "completed" }>, summary?: string }` |
  429. | `tool_call` | `{ toolCallId: string, label: string, status: "pending" \| "running" \| "completed" \| "failed", input?: string, output?: string }` |
  430. | `artifact` | `{ label: string, artifactId?: string, filename?: string, contentType?: string, url?: string, size?: number, kind?: string }` |
  431. | `done` | `{ status: "completed" | "rejected" | "cancelled", reason?: string, error?: string, output?: string }` |
  432. For protocol details, see:
  433. - [docs/AAMP_CORE_SPECIFICATION.md](./docs/AAMP_CORE_SPECIFICATION.md)
  434. ## Repository Layout
  435. ```text
  436. docs/
  437. AAMP_CORE_SPECIFICATION.md
  438. assets/
  439. packages/
  440. sdks/
  441. nodejs/
  442. python/
  443. go/
  444. aamp-cli/
  445. aamp-openclaw-plugin/
  446. aamp-acp-bridge/
  447. aamp-cli-bridge/
  448. aamp-feishu-bridge/
  449. aamp-wechat-bridge/
  450. ```
  451. Examples in this repo may reference `meshmail.ai` as a compatible AAMP host.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.