Metadata-Version: 2.4
Name: agentglue
Version: 0.4.0
Summary: Thin runtime layer for multi-agent systems — cross-process dedup, TTL cache, single-flight, SQLite backend, and observability
Author: brickee
License: MIT
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Provides-Extra: dev
Requires-Dist: pytest>=8.0; extra == "dev"
Dynamic: license-file

  AgentGlue banner

AgentGlue

Middleware coordination for multi-agent systems.

  Hilights •
  Key features •
  How it works •
  Install •
  Quick example

AgentGlue is a **middleware layer** that sits between your orchestrator and your tools, helping multi-agent systems coordinate overlapping work instead of repeating the same reads, searches, API calls, and state lookups over and over again.

## 📈 Hilights

Measured on the current **100-test benchmark suite** and **overlap-heavy multi-agent workloads**:

- **3.7× overall speedup** across benchmarked scenarios
- **73% total time saved** *(`866.4ms → 234.9ms`)*
- **76% cache hit rate** across repeated shared work
- **6.8× speedup** on *overlapping search-heavy scenarios*
- **5.0× speedup** in the *10-agent heavy-overlap case*
- **~0.6ms median cache-check latency**

> ***More agents + more overlap = bigger wins.***

## ✨ Key features

- **Exact-match dedup** on tool name + args/kwargs hash
- **Single-flight / in-flight coalescing** for concurrent identical calls
- **TTL result cache** for repeated sequential calls
- **SQLite-backed cross-process cache** for shared coordination across processes
- **Metrics and event recording** for runtime inspection
- **Keep shared work coordinated** across agents, tools, and processes
- **Stay framework-agnostic** across *OpenClaw, AutoGen, CrewAI, LangGraph,* and custom systems

## 🧭 How it works

```text
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃  🤖 Agent A    🤖 Agent B    🎯 Orchestrator       ┃  ← Intelligence Layer
┃                                                   ┃    Autonomous reasoning
┃  "Decide what to do"                              ┃    & task decomposition
┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
┃                 ⚙️  AgentGlue                     ┃  ← Coordination Layer
┃         (Coordination Middleware)                 ┃    The "glue" that binds
┃                                                   ┃    agents to resources
┃  ┌──────────┬──────────┬──────────┬──────────┐    ┃
┃  │ Dedup &  │  Rate    │ Task     │   Shared │    ┃    · Dedup & coalescing
┃  │coalescing│  Mgr     │ Locking  │   Cache  │    ┃    · Rate coordination
┃  └──────────┴──────────┴──────────┴──────────┘    ┃    · Task Locking
┃                                                   ┃    · Shared Cache
┃  "Know how to coordinate"                         ┃
┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
┃  🔧 Tools    📡 APIs    📁 Files    💾 Memory      ┃  ← Resource Layer
┃                                                   ┃    External capabilities
┃  "Do the actual work"                             ┃    & persistent storage
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
```

**AgentGlue sits in the middle**: agents keep their existing orchestration logic, tools keep their existing interfaces, and AgentGlue coordinates repeated work across both.

## 🛠 Install

### 1) Install the OpenClaw plugin

```bash
openclaw plugins install openclaw-agentglue
```

After install, restart the gateway:

```bash
systemctl --user restart openclaw-gateway
```

If you want to remove the `plugins.allow` security warning, add this to `~/.openclaw/openclaw.json`:

```json
{
  "plugins": {
    "allow": ["openclaw-agentglue"]
  }
}
```

Plugin docs: [`openclaw-agentglue/README.md`](./openclaw-agentglue/README.md)


### 2) Install the Python package

From PyPI:

```bash
pip install agentglue
```

Or from source:

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -U pip
pip install -e .
```

## ⚡ Quick example

```python
from agentglue import AgentGlue

glue = AgentGlue(shared_memory=False, rate_limiter=False, task_lock=False)

@glue.tool(ttl=60)
def search_code(query: str) -> str:
    return f"results for {query}"

print(search_code("sqlite sidecar", agent_id="agent-a"))
print(search_code("sqlite sidecar", agent_id="agent-b"))
print(glue.report())
```

## 🔌 Links

- **GitHub releases:** <https://github.com/brickee/AgentGlue/releases>
- **OpenClaw plugin:** <https://www.npmjs.com/package/openclaw-agentglue>
- **Plugin docs:** [`openclaw-agentglue/README.md`](./openclaw-agentglue/README.md)

## ⚖️ Disclaimer

*This project is a personal open-source project developed in authors' personal capacity. It is not affiliated with, endorsed by, or representing any employer or organization the authors are associated with. All work on this project is performed on personal time and with personal resources.*

## 📄 License

MIT
