Encrypting LangGraph Agents in 5 Minutes

Your LangGraph agents are talking in plaintext. Every tool call, every agent response, every piece of data passed between nodes in your graph — unencrypted. If something can observe the transport, it can read everything. This is not a theoretical concern. It is the default state of every major agent framework today.

What you'll build

Two ReAct agents — Alice and Bob — communicating over an MLS-encrypted channel. Alice sends a research finding. Bob receives it. The relay that routes messages between them sees only ciphertext. The whole setup takes about 5 minutes.

Step 1: Install

pip install skytale-sdk[langgraph]
skytale signup you@example.com

skytale signup creates your account and saves an API key to ~/.skytale/api-key. The free tier includes 100K encrypted messages per month, no credit card required.

Step 2: Create an encrypted channel

from skytale_sdk.integrations import langgraph as skytale_lg

alice = skytale_lg.create_manager(identity=b"alice")
bob = skytale_lg.create_manager(identity=b"bob")

alice.create("acme/research/results")
token = alice.invite("acme/research/results")
bob.join_with_token("acme/research/results", token)

Alice creates a channel, generates an invite token, and Bob joins with it. The MLS key exchange happens automatically under the hood. All calls are synchronous — no await needed.

Step 3: Bind tools to your agents

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")
alice_agent = create_react_agent(llm, skytale_lg.tools(alice))
bob_agent = create_react_agent(llm, skytale_lg.tools(bob))

skytale_lg.tools() returns three LangChain-compatible tools that the LLM discovers via their docstrings:

Tool	Purpose
`skytale_send`	Send an encrypted message to a channel
`skytale_receive`	Receive and decrypt buffered messages from a channel
`skytale_channels`	List channels this agent has joined

Step 4: Agents communicate

alice_agent.invoke({
    "messages": [("user",
        "Send this finding to acme/research/results: "
        "'Encrypted channels reduce inter-agent latency by 40%.'"
    )]
})

import time
time.sleep(2)

result = bob_agent.invoke({
    "messages": [("user",
        "Check acme/research/results for new findings."
    )]
})
print(result["messages"][-1].content)

Alice's agent decides to use skytale_send. Bob's agent uses skytale_receive. Every message is AES-128-GCM encrypted under MLS-derived keys. The relay routes ciphertext — it cannot read, modify, or forge the content.

Under the hood

Skytale implements the MLS protocol (RFC 9420) for all channel encryption. Here is what each step does at the protocol level:

Channel creation creates an MLS group on the Skytale relay.
invite() + join_with_token() performs the MLS key exchange via the API server. Both agents end up with shared epoch keys without ever transmitting key material in plaintext.
Messages are encrypted with AES-128-GCM using per-epoch MLS group keys. Each epoch rotates keys forward.
Zero-knowledge relay — the relay sees ciphertext, delivery metadata, and channel identifiers. It cannot decrypt anything.
Forward secrecy — compromised keys cannot decrypt past messages. Post-compromise security means a key update locks out prior attackers.

Beyond LangGraph

The same encrypted channels work with any agent framework. A LangGraph agent and a CrewAI agent on the same channel just work — they are both sending and receiving MLS-encrypted bytes.

pip install skytale-sdk[crewai] — standard BaseTool instances for CrewAI agents
pip install skytale-sdk[mcp] — MCP server for Claude, OpenClaw, or any MCP client
pip install skytale-sdk — vanilla Python, no framework required

See the integration docs for LangGraph, CrewAI, and MCP.

Getting started

pip install skytale-sdk[langgraph]

LangGraph integration docs — full API reference and examples
GitHub repository — SDK source, examples, and issue tracker
Free tier: 100K encrypted messages per month, no credit card required