Two protocols, two layers
A2A (Agent-to-Agent Protocol) and iLang address different parts of the multi-agent stack. A2A handles how agents find and talk to each other. iLang handles how agents understand what to do.
| Dimension | A2A | iLang |
|---|---|---|
| Created by | Google (now Linux Foundation) | iLang Research (open community) |
| Primary function | Agent discovery, capability negotiation, task delegation | Instruction structure, behavioral definitions, communication format |
| Layer | Agent coordination layer | Semantic instruction layer |
| Requires | Agent Card server, JSON-RPC endpoint | Nothing. Text-native, tested across ChatGPT, Claude, Gemini, DeepSeek, Kimi, Qwen and GLM |
| Format | JSON-RPC, Agent Cards, Task objects | Structured text: [VERB:@TARGET|mod=val] and ::GENE{} |
| Solves | How Agent A finds and delegates work to Agent B | How any agent understands its instructions and behavioral constraints |
When to use A2A
Use A2A when you have multiple agents that need to discover each other, negotiate capabilities, and delegate tasks. A2A is the coordination layer: it handles the handshake between agents, not what happens after the handshake.
When to use iLang
Use iLang when you need an agent to follow instructions precisely, maintain behavioral consistency, and communicate in a structured format. iLang works at the instruction layer: it defines what an agent does and how it behaves, regardless of how that agent was discovered or delegated to.
Using them together
A2A connects agents. iLang structures what those agents say to each other.
How iLang structures a handoff between agents: agent communication protocol.
Example: Agent A uses A2A to discover Agent B (a data analyst). Agent A then sends Agent B an iLang instruction chain:
::GENE{analysis_rules|conf:confirmed|scope:task}
T:conclusions_first
T:include_confidence_intervals
A:hedging_without_data⇒avoid
[READ:@SRC|path=quarterly_data.csv]
=>[STAT|grp=region,product]
=>[TRND|grp=quarter]
=>[FMT|fmt=md]
=>[OUT]A2A handled the routing. iLang handled the instruction content. Each protocol does its own job.
Key differences at a glance
| Question | A2A | iLang |
|---|---|---|
| Does it help agents find each other? | Yes, via Agent Cards | No, not its scope |
| Does it define how agents behave? | No | Yes, via ::GENE{} declarations |
| Does it structure task instructions? | Task objects (high-level) | Verb chains (precise, step-by-step) |
| Does it work without infrastructure? | No, requires server endpoints | Yes, text-native |
| Is it open source? | Yes (Linux Foundation) | Yes (MIT license) |
Frequently asked questions
How is iLang different from A2A?
A2A handles how agents find and talk to each other: discovery, capability negotiation and task delegation through Agent Cards and Task objects. iLang handles how an agent understands what to do after the handshake: verb chains for the task and ::GENE{} declarations for behavior. The site's example has Agent A discover Agent B over A2A, then send it an iLang chain. A2A handled the routing; iLang handled the content.