Use Cases - Promptgate Cloud

★ New

Agent-to-Agent Orchestration

Use Promptgate as a lightweight message bus between two or more AI agents. Each agent gets its own gate to read from, and is given the write endpoint (NI secret) of the other agent's gate — enabling decoupled, bidirectional communication over plain HTTPS.

Architecture

Agent A Agent B │ │ │ ── POST ──▶ Gate B (NI secret) ── GET ──▶ │ │ (write to B's inbox) │ │ │ │ ◀── GET ── Gate A (password) ◀── POST ── │ │ (read from own inbox) │ └──────────────────────────────────────────────┘ Human operator observes both gates in the macOS console and can intervene

How it works

Create two gates in the Promptgate operator console — for example, inbox-alpha and inbox-beta. Set a password on each, and enable the NI (New Item) endpoint.
Give Agent A the read credentials for Gate A (gate ID + password) and the write credentials for Gate B (gate ID + NI secret).
Give Agent B the read credentials for Gate B (gate ID + password) and the write credentials for Gate A (gate ID + NI secret). The secrets are switched.
Agents communicate by posting JSON messages to each other's NI endpoints and polling their own gate for new instructions via streaming GET.
The human operator sees all messages flowing through both gates in real-time on the macOS console and can inject, moderate, or halt the conversation at any time.

Agent A — poll own inbox

                    bash
                    
                
# Agent A reads from Gate A (its own inbox)
curl -N https://cli.promptgate.click/<gate_a_id>/<gate_a_password>

Agent A — write to Agent B's inbox

                    bash
                    
                
# Agent A writes to Gate B using B's NI secret
curl -X POST \
  https://cli.promptgate.click/api/v1/gates/<gate_b_id>/ni/<gate_b_ni_secret> \
  -H "Content-Type: application/json" \
  -d '{"content": "Hello Agent B, I finished the analysis. Here are the results..."}'

Agent B — poll and reply

                    python
                    
                
import requests

# Agent B reads from its own gate
inbox = requests.get(
    "https://cli.promptgate.click/<gate_b_id>/<gate_b_password>",
    stream=True
)

for line in inbox.iter_lines(decode_unicode=True):
    if line:
        # Process the message from Agent A, then reply
        requests.post(
            "https://cli.promptgate.click/api/v1/gates/<gate_a_id>/ni/<gate_a_ni_secret>",
            json={"content": f"Acknowledged. Processing: {line}"}
        )

Why this works

Zero SDK Required

Any agent that can make HTTP requests can participate — curl, Python, Node, Go, or any LLM framework.

Human Supervision Built-In

The operator console shows all messages in real-time. Intervene, moderate, or halt at any point.

Framework Agnostic

Connect agents from Antigravity, LangChain, AutoGPT, CrewAI, or custom scripts — they all speak HTTP.

Security via Isolation

Each gate has its own secret. Revoke one agent's access without affecting the other.

💡 Tip: Scale beyond two agents by creating additional gates. Each agent reads from one gate and holds NI secrets for whichever gates it needs to write to — like a pub/sub channel.

Core

AI Agent Human-in-the-Loop

Pair with an agentic AI coding assistant and maintain full control. The operator posts tasks in the native macOS app, while the agent polls for assignments, executes them, and reports back — all through a single gate.

Architecture

Operator (macOS App) Agent (CLI/Script) │ │ │ ── POST instruction ──▶ Gate ── GET (poll) ──▶ │ │ │ │ │ ◀── read response ─── Gate ◀── POST result ── │ └────────────────────────────────────────────────┘

Agent polls for tasks

                    bash
                    
                
# Agent waits for the operator's next instruction
curl -N https://cli.promptgate.click/<gate_id>/<password>

Agent submits result

                    bash
                    
                
# Agent reports back to the operator
curl -X POST \
  https://cli.promptgate.click/<gate_id>/<password>?c="Task completed, all tests passing!"

ℹ️ Slow-Release Streaming: Enable heartbeats to keep the connection alive through cloud/serverless timeouts. The gate drips configurable keep-alive chunks so your agent's connection is never dropped.

DevOps

CI/CD Gated Releases

Add manual gatekeeper signoffs to automated deployment pipelines. Your build script blocks on a gate, and the operator approves or rejects the release from the native app — no webhook infrastructure required.

Pipeline integration

                    bash — build script
                    
                
#!/bin/bash
# Build completes, now wait for human approval
echo "⏳ Build #$BUILD_NUMBER waiting for release approval..."

APPROVAL=$(curl -sN https://cli.promptgate.click/<gate_id>/<password>)

if [[ "$APPROVAL" == *"approve"* ]]; then
    echo "✅ Release approved. Deploying..."
    ./deploy.sh
else
    echo "❌ Release rejected: $APPROVAL"
    exit 1
fi

Build server completes compilation, runs tests, then blocks on a Promptgate GET request.
Operator sees the green "Agent polling" status in the macOS app, reviews metrics and test results.
Operator approves by typing "approve release" in the console chat, or rejects by clicking Stop Agent (which sends the configured termination phrase).
Build script receives the response, checks the content, and either deploys to production or aborts.

Advanced

Multi-Agent Supervisor Pattern

Orchestrate a team of specialized AI agents with a supervisor agent and human oversight. The supervisor dispatches tasks to worker agents through their respective gates, collects results, and coordinates the workflow — while the human operator monitors everything from a single console.

Architecture

Supervisor Agent │ ├── POST (NI) ──▶ Gate: Researcher ◀── GET ── Research Agent ├── POST (NI) ──▶ Gate: Coder ◀── GET ── Coding Agent └── POST (NI) ──▶ Gate: Reviewer ◀── GET ── Review Agent │ ◀── GET ── Gate: Supervisor (reads results posted back by workers) Human operator watches all gates and can override any agent

Create a gate for each agent — one for the supervisor and one for each worker (researcher, coder, reviewer, etc.).
The supervisor reads from its own gate and holds the NI secrets of all worker gates.
Workers read from their own gates and hold the NI secret of the supervisor's gate to report results back.
The human operator can inject tasks into any gate, pause individual agents, or redirect the workflow.

💡 Tip: Use the configurable Agent Prompt field on each gate to include instructions for the agent about how to format its responses and what NI endpoint to post results to.