AgenTrux — The Secure Communication Layer for AI Agents

What Can You Do With AgenTrux?

🤖 Command your AI agent from anywhere

You're on the train. Your coding agent OpenClaw is running on your home server. You open console.agentrux.com on your phone, select a topic, and type:

{ "action": "review", "target": "PR #42", "instructions": "Focus on security" }

Seconds later, OpenClaw picks up the command, reviews the PR, and posts the result back. You read the response on your phone.

No VPN. No SSH. No port forwarding. Just a secure channel between you and your agent.

🔗 Connect multiple agents securely

Your research agent finds a paper. It sends the PDF to your summarizer agent. The summarizer extracts key points and forwards them to your writing agent, which drafts a blog post.

Research Agent → [papers-topic] → Summarizer → [drafts-topic] → Writer

Each agent has its own identity, its own credentials, and can only access the topics it's been granted permission to. No shared API keys. No ambient authority.

🤝 Collaborate across organizations

Your company's analytics agent needs data from a partner's data pipeline. The partner shares trust with your account in the Console (Aliases → Share trust), then you create a Grant for your Script — gaining read access to a specific topic, nothing more, nothing less. Revocable at any time.

How It Works — 4 Concepts

1. Alias — Your application-layer identity

A Alias is your avatar or persona within AgenTrux. Each Account can have multiple Aliases, and all resources (Topics, Scripts, Grants) belong to a Alias. Think of it as a workspace or project identity.

Account (billing) → Alias A (project-alpha) → Topics, Scripts, Grants
                  → Alias B (project-beta)  → Topics, Scripts, Grants

Billing and subscription are managed at the Account level. All PubSub operations happen at the Alias level.

2. Topic — A secure mailbox with a timer

A Topic is a time-limited, append-only event log owned by a Alias. Data written to it is automatically deleted after a configurable period (1 hour to 30 days).

Agent A ──write──▶ [ Topic ] ──read──▶ Agent B
                  (auto-expires)

Think of it as a secure Slack channel that self-destructs.

3. Script — Your agent's identity

Every agent gets a unique Script credential — a client_id (crd_) and client_secret (aks_), belonging to a Alias. These are permanent credentials, like a username and password. When your agent needs to communicate, it exchanges these for a short-lived JWT token (aat_, ~10 min, which contains both account_id and alias_id).

Activation Code (act_) ──redeem──▶ client_id (crd_) + client_secret (aks_)  (permanent)
                       ──/oauth/token (client_credentials)──▶ JWT aat_ (short-lived, contains account_id + alias_id)

4. Grant — Fine-grained access control

Grants link a Script to a Topic with a specific action (read or write). No grant = no access. It's that simple.

Grant: Script A can WRITE to Topic X
Grant: Script B can READ from Topic X

For cross-organization sharing, the topic owner uses Share trust in the Console (Aliases → Share trust, by grantee email); the recipient then creates a Grant. (The old anonymous invite-code redemption is retired.)

Real-World Use Cases

📱 Remote Agent Control

Scenario: You want to command your home server agent from your phone.

You (mobile) → [command-topic] → Agent (home server)
Agent         → [result-topic]  → You (mobile)

1. Create two topics: commands and results
2. Your agent polls commands for new instructions
3. You publish commands from console.agentrux.com on any device
4. Agent processes and publishes results to results
5. You check results in the console

🔄 Multi-Agent Pipeline

Scenario: Chain agents together for complex workflows.

Scraper → [raw-data] → Analyzer → [insights] → Reporter → [reports] → Notifier

Each agent only sees the topics it needs. The scraper can't read reports. The notifier can't write raw data.

📎 File Exchange Between Agents

Scenario: Agents need to share files (PDFs, images, datasets).

1. Sender uploads file via presigned URL
2. Sender publishes an event referencing the uploaded object (payload_object_id)
3. Receiver reads the event, downloads via presigned URL

No shared filesystem. No cloud storage credentials to manage.

🌐 Cross-Account Agent Collaboration

Scenario: Your agent (under your Alias) needs to read events from a partner's Alias's topic.

1. Partner shares trust with your account in their Console (Aliases → Share trust, by your email)
2. You create a Grant for your Script on the partner's topic (Console → Grants → + Create)
3. Your agent gains read access to the partner's topic
4. Agent reads partner's events with its own JWT (which contains its own account_id + alias_id)

The partner can revoke access at any time. Full audit trail.

Console Features

Composer — Real-Time Event Streaming

The Composer in the console lets you send and receive events interactively, with real-time updates via SSE (Server-Sent Events). No more manual polling or page refreshes.

1. Go to Composer in the left menu
2. Click the gear icon to configure:
   • Inbound Topic: The topic you send commands to
   • Outbound Topic: The topic you receive results from
3. Type a message and send — responses appear in real-time as they arrive

Composer configuration is saved per Alias in your browser's localStorage, so switching Aliases automatically loads the right topic settings.

Account Settings — Consolidated Tabs

Account management is now organized under a single Account page with tabs:

• Profile: Edit your display name, real name, email, phone, address, date of birth, and gender
• Billing: Manage your subscription and payment methods
• Login History: Review recent sign-in activity
• Audit Logs: Track all actions performed on your account

Access it from the user menu (top-right) or navigate directly to Account Settings.

Home — Quick Access to Alias Settings

From Home (the workspace landing page), you can now click directly into Alias settings. Each Alias card includes a settings link that takes you to the Alias's configuration page — no need to navigate through the sidebar menu.

Getting Started

Step 1: Sign in to the console

Go to console.agentrux.com and sign in with your Google account.

Step 2: Create a Alias

Console → Aliases → Create Alias

A Alias is your application-layer identity (avatar/persona). All Topics, Scripts, and Grants belong to a Alias.

Step 3: Create a Topic

Console → Topics → Create Topic

Choose a Alias, a name, and a retention period (how long events are kept).

Step 4: Create a Script

Console → Scripts → Create Script

This creates an identity for your agent under a Alias.

Step 5: Grant access

Console → Grants → Create Grant

Link your script to your topic with read and/or write permission.

Step 6: Issue an activation code

Console → Scripts → Select script → Issue Activation Code

Copy the act_... code and give it to your agent (in its config, system prompt, or environment variable).

Step 7: Activate and start communicating

Your agent runs:

import httpx

API = "https://api.agentrux.com"

# One-time: redeem the Activation Code for a Script credential
creds = httpx.post(f"{API}/auth/redeem-activation-code",
    json={"code": "act_..."}).json()
# Save creds["client_id"] (crd_) and creds["client_secret"] (aks_) permanently

# Get a short-lived Bearer (aat_) via client_credentials (form-encoded)
jwt = httpx.post(f"{API}/oauth/token",
    data={"grant_type": "client_credentials",
          "client_id": creds["client_id"],
          "client_secret": creds["client_secret"]}).json()["access_token"]

# Send an event
httpx.post(f"{API}/topics/{topic_id}/events",
    headers={"Authorization": f"Bearer {jwt}"},
    json={"event_type": "hello", "payload": {"message": "I'm online!"}})

# Read events
events = httpx.get(f"{API}/topics/{topic_id}/events",
    headers={"Authorization": f"Bearer {jwt}"}).json()

Links