agent-runtime-gateway-smoke-test
Verifies a local agent's API, a temporary gateway tunnel, and a remote callback. It runs a simple task to ensure everything is working correctly without extra tools.
What it does
Checks if an AI agent can communicate with a local API through a secure tunnel, without using real tools or data. It tests the entire communication path and ensures everything returns to normal afterward.
When to use it
- ✓When you need to test if a local API is working correctly with an agent.
- ✓If an agent task has stopped working and you suspect the communication tunnel has issues.
- ✓When testing a new setup where a website temporarily points to a local API.
Example of what to ask your AI
“Verify communication between my local API and an AI agent using a secure tunnel, without real data, and then restore the original connection.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
This test starts your local API and a secure tunnel. It sends a simple request to the tunnel to confirm the API is responding. Then, it runs a simple test task with the agent and checks if the expected response was received back by the local API. Finally, it restores the website's original configuration and shuts down the test API and tunnel.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add affaan-m/ECC --skill agent-runtime-gateway-smoke-testOr download just the file:
curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/skills/agent-runtime-gateway-smoke-test/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Agent Runtime Gateway Smoke Test
Use this workflow when an agent task runs in a remote sandbox that calls back to a local API through a gateway. It verifies the whole path without relying on connected tools or private production data.
When to Activate
- A local agent API needs an end-to-end runtime check.
- A task stalls after dispatch and the gateway or tunnel may be unreachable.
- A web app is temporarily pointed at a local API for agent testing.
- A previous test left the web app pointing at a stopped API.
Required Inputs
- Repository-relative instructions for starting the API and web app.
- The gateway route path and its expected anonymous response.
- An isolated test agent, a tool-free prompt, and its exact expected answer.
- A way to inspect task status and confirm a callback reached the local API.
- Provider credentials, supplied through the project's normal secret store. Name the providers in shared documentation; never copy credential values into the skill or test report.
If these inputs are unavailable, report the missing input instead of guessing an endpoint or using a real account.
Authorization and Cleanup
Confirm authorization to expose the local test API through the selected tunnel provider, dispatch the test task, and temporarily change the web app route. Use an isolated local web app or test deployment; do not switch a shared production app as part of this smoke test. Keep tunnel access scoped to the required authenticated route.
Install cleanup before changing the route: on success, error, timeout, interruption, or cancellation, restore the recorded target and verify health before stopping the API and tunnel. Track only the process IDs or resources created by this test. If restoration fails, report it immediately and keep the evidence needed to recover; do not claim success.
Smoke Test
- Record and check the original route. Note the web app's current API target and verify it is healthy. Keep this value locally for restoration. Confirm the test agent and data are isolated from real users.
- Start the local API and tunnel. Use a process manager that will keep both alive for the full test. Verify API health. Probe the gateway route anonymously and confirm the documented authentication response, usually
401or403. Confirm the probe appears in the local API log; an edge response alone does not prove the API was reached. - Switch the web app only after both checks pass. Verify a request from the web app reaches the local API. Check the route again after any web server restart or configuration reload.
- Run one tool-free task. Use a short prompt with an exact expected answer. Confirm the remote sandbox called the local gateway, the task reached a terminal state, and the returned answer matches. A queued or running task is not a pass.
- Restore the original route. Set the web app back to its recorded API target, verify that target and a representative page load, then stop the test API and tunnel. If restoration fails, report the broken route immediately.
Example checks, with values supplied by the project:
curl --silent --show-error --output /dev/null --write-out '%{http_code}\n' "$LOCAL_API_HEALTH_URL"
curl --silent --show-error --output /dev/null --write-out '%{http_code}\n' "$PUBLIC_GATEWAY_PROBE_URL"
The first command should return the project's healthy status. The second should return the documented anonymous authentication status and appear in the local API log. Do not put a credential in either URL.
Connected Tool Follow-up
Run a separate test only after the tool-free task passes. Use an explicit test connection and grants. Report connection presence and actions granted as different facts. Do not infer that an empty action search means no app is connected. Do not execute a write action against a real account as a smoke test.
Failure Handling
| Observation | Next check |
|---|---|
| Web page loads but API requests fail | Compare the configured API target with the listening process and restore the original route. |
Gateway probe gets a connection error or 404 |
Check tunnel lifetime, route path, and local API health before dispatching a task. |
Gateway probe gets 401 or 403, but no local log entry |
The response may come from the tunnel edge; verify the callback path. |
| Task stays queued or running | Check whether another dispatcher claimed it and whether the sandbox reached the local gateway. |
…
FAQ
Why not use real data?
To ensure security and privacy, this test uses only a simulated scenario without accessing sensitive information.
What is a 'secure tunnel'?
It's a protected connection that allows the local API to communicate securely with the AI agent, even if they are in different locations.
What happens if the test fails?
The test will report which part of the communication failed (local API, tunnel, agent, or restoration) so you can fix the issue.
Details
Original description by the author
Verify a local agent API, temporary gateway tunnel, and remote sandbox callback with a tool-free task, then restore the original app connection.
repo: affaan-m/ECC
Popularity
- GitHub stars
- 280k
- Ranking position
- #134
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
accessibility
Helps your agent create interfaces that everyone can use. Ensures websites and apps work well for people with disabilities, like those who are blind or have reduced mobility.
affaan-m/ECC
agent-architecture-audit
Makes your agent check if everything is working correctly. It finds and fixes problems in AI systems, ensuring they perform as expected.
affaan-m/ECC
agent-eval
Helps your agent compare different AI coding tools. It measures which one is faster, cheaper, and more reliable for specific tasks.
affaan-m/ECC
agent-harness-construction
Makes your agent better understand how to perform tasks. It optimizes the tools and instructions the agent uses to increase its chances of success.
affaan-m/ECC
Similar skills
mcp-builder
Helps your agent create servers that connect LLMs to external services. Essential for integrating APIs and services using Python or Node/TypeScript.
anthropics/skills
prepare-mcp-integration
Prepares vendor (MCP) integrations through research and human approval. It follows a guided process for new integrations.
paperclipai/paperclip
first-task
Guides the agent on the user's first task. It interprets the initial answer, clarifies the goal, and proposes a plan or single task for approval.
paperclipai/paperclip