Real-world use cases:

- Store screenshots for visual debugging
- Cache JSON API responses across steps
- Save generated images for later use
- Build code snippet libraries
- Persist config files between sessions
- Implement undo/redo stacks

What will you build?

New: Track where your data comes from!

Every clipboard entry now has a source field:

- ui - Created via web interface
- sdk - Via JavaScript, Python, or Go SDK
- mcp - Via MCP proxy tools

Perfect for auditing multi-agent workflows!

// JavaScript SDK
const entry = await client.clipboard.set({
name: 'api_response',
value: JSON.stringify(data)
});
console.log(entry.source); // 'sdk'

# Python SDK
entry = client.clipboard.get(name="api_response")
print(entry.source) # 'sdk'

All SDKs: docs.plugged.in/sdks

For developers:

Multiple access methods:

- MCP tools for Claude, Cursor, Windsurf
- JavaScript/TypeScript SDK
- Python SDK (sync + async)
- Go SDK
- REST API

Your AI workflows, your language choice!

Security-first design:

- Profile-level isolation
- Visibility controls (private/workspace/public)
- Rate limiting per operation type
- Content encoding validation
- Database-level integrity constraints

Your data stays protected.

What makes Clipboard special:

- Named entries: clipboard["api_response"]
- Indexed arrays: clipboard[0], clipboard[1]
- Push/Pop stack operations
- Content type detection (application/json, image/png…)
- Auto-expiration with TTL
- Visual preview for images in UI
Perfect for complex AI workflows!

Store ANY content type your AI needs:

- JSON data & API responses
- Base64-encoded images (screenshots, diagrams)
- Code snippets & configs
- Markdown documents
- Binary files via hex encoding
- Structured data for multi-step workflows
- 2MB per entry - plenty for most use cases!

This is the foundation for truly autonomous AI agents:

✅ Governed (Station control)
✅ Observable (heartbeats + metrics)
✅ Secure (protocol-level)
✅ Interoperable (MCP, A2A, OTEL)
✅ Production-ready (live infrastructure)

Docs: docs.plugged.in/agents

Deploy your first agent RIGHT NOW:

curl -X POST plugged.in/api/agents
-H "Authorization: Bearer YOUR_KEY"
-d '{"name": "my-agent"}'

30 seconds later: my-agent.is.plugged.in ✅

📚 Documentation is COMPREHENSIVE:

• 2,993 lines across 6 guides • 50+ code examples (cURL, JS, Python) • Complete REST API reference • Architecture deep dives • Production deployment patterns

docs.plugged.in/agents

Built on 19 years of data center experience from VeriTeknik

This isn't theory. It's production-hardened infrastructure patterns applied to autonomous AI.

Every design decision comes from real operational experience

Production infrastructure LIVE NOW:

🌐 is.plugged.in cluster
📍 Single IP, SNI-based routing
🔒 Automatic Let's Encrypt TLS
☸️ K3s with agent namespace isolation
🚫 Non-root containers (UID 1001)
📊 Full observability (OpenTelemetry)

Dual-Profile Architecture:

🔐 PAP-CP (Control Plane): • gRPC/mTLS for lifecycle ops • Ed25519 signatures + replay protection • Heartbeats, provisioning, termination

🔧 PAP-Hooks (Open I/O): • JSON-RPC 2.0 over WebSocket • MCP tool access, A2A delegation • OAuth 2.1

Normative State Machine: NEW → PROVISIONED → ACTIVE ↔ DRAINING → TERMINATED ↓ KILLED

Invalid transitions = rejected Station has exclusive kill authority State integrity = protocol-enforced

PAP enforces STRICT SEPARATION:

✅ Heartbeat (liveness only): {mode: "IDLE", uptime: 3600}

✅ Metrics (separate channel): {cpu: 87, memory: 2048, requests: 1523, ...}

Result: Aggressive zombie detection without false positives

🧟 THE ZOMBIE PREVENTION SUPERPOWER

Most agent systems mix liveness signals with metrics: ❌ Heartbeat: {status: "ok", cpu: 87%, memory: 2GB, ...}

Problem: Large payloads saturate control planes Result: Can't detect zombies fast enough

PAP fixes this by being the SUBSTRATE layer - not orchestration, but how agents live, breathe, and die across infrastructure

Think: TCP/IP for agent lifecycle management

Your agent gets a name: focus.is.plugged.in DNS-safe, TLS-enabled, production-ready

The problem: Every AI platform has isolated tools, documents, and context

You're constantly: • Re-uploading documents • Reconfiguring tools • Losing continuity between models

It's 2025 and we're still treating AI like it's 2020