joshualamerton/Intentmesh-agent2agent

IntentMesh-agent2agent

IntentMesh is an open protocol and reference architecture for structured negotiation between autonomous software agents.

Quick Start

Clone the repository and run the multi-agent simulation demonstrating intent negotiation.

git clone https://github.com/joshuamlamerton/Intentmesh-agent2agent
cd Intentmesh-agent2agent
python examples/multi_agent_demo.py

As software systems become agentic, the interaction model is shifting from:

human → software → outcome

to

agent → agent → coordinated outcome

Most current agent frameworks enable agents to call APIs, invoke functions, or exchange messages. However they lack mechanisms for:

• constraint validation
• negotiation between agents
• counterfactual outcome simulation
• trust evaluation between systems

IntentMesh proposes a negotiation layer that allows agents to exchange structured intent contracts, simulate outcomes, and coordinate execution safely.

Motivation

Autonomous systems will increasingly interact directly with other autonomous systems.

Examples include:

consumer agents negotiating purchases
supply chain agents coordinating logistics
financial agents executing transactions
infrastructure agents allocating compute resources

Without structured negotiation infrastructure, these systems remain fragile.

IntentMesh introduces a layer that enables agents to:

express goals
evaluate constraints
simulate outcomes
assess trust before execution

Core Idea

Instead of simple API requests, agents exchange Intent Contracts.

An Intent Contract describes:

objective
constraints
preferences
execution policies
risk tolerance

Receiving agents evaluate the request and return execution plans rather than simple responses.

Execution plans include:

possible execution paths
estimated costs
risk scores
simulation results

System Architecture

IntentMesh sits between communication protocols and execution layers.
Protocol development and specification discussion are tracked in Issue #1.

Applications
commerce | travel | procurement | real estate

Execution Layer
APIs | payments | booking | compute services

IntentMesh Core
intent schema
constraint engine
negotiation engine
counterfactual simulator
trust ledger

Communication Layer
HTTP | WebSocket | A2A | MCP | gRPC

IntentMesh integrates with existing communication protocols rather than replacing them.

Core Components

Intent Schema
Defines the machine-readable structure of agent requests.

Constraint Engine
Evaluates whether requests comply with local policies.

Negotiation Engine
Allows agents to modify requests, propose alternatives, or reject actions.

Counterfactual Sandbox
Simulates potential outcomes before execution.

Trust Ledger
Records historical interactions between agents to evaluate reliability.

Example Intent Contract

{
  "intent_id": "abc-123",
  "objective": "purchase_primary_residence",
  "constraints": {
    "location": "Austin, TX",
    "budget_max": 750000,
    "bedrooms_min": 3
  },
  "execution_policy": {
    "require_verified_counterparty": true,
    "max_agents_involved": 5
  }
}

Negotiation Response

{
  "intent_id": "abc-123",
  "accepted": true,
  "plan_options": [
    {
      "execution_path": [
        "listing_agent",
        "mortgage_agent",
        "insurance_agent"
      ],
      "score": 0.89,
      "risk_score": 0.11,
      "estimated_cost": 742000
    }
  ]
}

Example Use Case

US home purchase coordination.

A buyer agent submits constraints:

budget under $750k
minimum 3 bedrooms
school rating above 7

Multiple agents respond:

listing portal agent
mortgage underwriting agent
insurance pricing agent
title verification agent

IntentMesh aggregates results and returns ranked transaction paths.

Minimal Agent Flow

Buyer Agent
↓
Intent Contract
↓
IntentMesh Core
↓
Listing Agent evaluation
↓
Mortgage Agent simulation
↓
Negotiation Engine ranking
↓
Execution Plan returned

System Architecture

flowchart TB

A[Applications<br>Commerce / Travel / Real Estate / Procurement]

B[Execution Layer<br>APIs / Payments / Booking / Data Services]

C[IntentMesh Core]

C1[Intent Schema]
C2[Constraint Engine]
C3[Negotiation Engine]
C4[Counterfactual Simulator]
C5[Trust Ledger]

D[Communication Layer<br>HTTP / gRPC / WebSocket / A2A / MCP]

A --> C
C --> B
D --> C

C --> C1
C --> C2
C --> C3
C --> C4
C --> C5

Repository Roadmap

Phase 1

Define intent schema
Publish protocol documentation
Build minimal Python SDK

Phase 2

Constraint evaluation engine
Negotiation engine
Simulation framework

Phase 3

Trust ledger implementation
Agent reputation scoring

Phase 4

Agent discovery systems
Economic negotiation models
Adversarial agent defense

Proposed Repository Structure

intentmesh

docs
architecture.md
protocol.md

spec
intent_schema.json
trust_event_schema.json

core
constraint_engine
negotiation_engine
simulation_engine

sdk
python
typescript

examples
commerce_agent
property_agent

Running the Demo

A minimal example demonstrates how an agent evaluates an intent contract.

Run:

python examples/demo.py

This example simulates:

1. a buyer agent submitting an intent
2. an IntentMesh negotiation agent evaluating the request
3. generation of an execution plan

Multi-Agent Simulation

IntentMesh can be demonstrated with a simple three-agent interaction.

Agents involved:

Buyer Agent
Listing Agent
Mortgage Agent

Run the simulation:

python examples/multi_agent_demo.py

Flow:

Buyer agent creates an intent
Listing agent proposes properties
Mortgage agent evaluates financing
IntentMesh assembles an execution plan

Contribution Areas

constraint evaluation systems
counterfactual simulation frameworks
agent reputation models
economic negotiation algorithms

License

Apache 2.0