Back to skill

Security audit

free-tier-ai-router

Security checks for vulnerabilities and agentic risk

Overview

This AI-routing skill has a coherent purpose, but it handles API keys and installation repair in ways that can expose credentials or make under-disclosed local changes.

Install only after reviewing which provider keys it can read and which endpoints it may contact. Avoid passing API keys as command-line arguments, avoid running probe.py, quality.py, or ratelimit.py on shared machines until they stop putting keys in curl argv, and inspect providers.json before allowing custom endpoints or credential-backed discovery.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (5)

T09 · Insecure Skill Coding Practices

Error
Location
ratelimit.py:20
Finding
API Keys Exposed Through curl Process Arguments<![CDATA[ ## Vulnerability Details **File Location**: `probe.py:12-20,63-79`; `quality.py:36-59`; `ratelimit.py:20-43` **Vulnerability Type**: Sensitive credential exposure through command-line arguments **Risk Level**: High ### Vulnerable Code The affected utilities construct authentication headers containing provider API keys and pass those headers directly to `curl` through its argument vector. A representative complete request construction from `ratelimit.py` is: ```python if prov=='gemini': k=creds('gemini')['api_key'] url=f'https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent' h=['Content-Type: application/json',f'X-goog-api-key: {k}'] body=json.dumps({'contents':[{'parts':[{'text':'hi'}]}], 'generationConfig':{'maxOutputTokens':800}}) else: url,key,extra={ 'mistral':('https://api.mistral.ai/v1/chat/completions', creds('mistral')['api_key'],[]), 'openrouter':('https://openrouter.ai/api/v1/chat/completions', creds('openrouter')['api_key'], ['HTTP-Referer: https://arena.ai','X-Title: ArenaAgentMode']), 'kilo':('https://api.kilo.ai/api/gateway/chat/completions', creds('kilo')['api_key'], ['X-KILOCODE-FEATURE: arena-agent']), }[prov] h=['Content-Type: application/json',f'Authorization: Bearer {key}']+extra body=body_common p=subprocess.run( ['curl','-sS','-D','-','-o','/dev/null','-w','%{http_code}',url, '-X','POST','--data-binary','@-','--max-time','40']+ [x for hh in h for x in ('-H',hh)], input=body,capture_output=True,text=True ) ``` `probe.py` and `quality.py` use the same vulnerable pattern by appending secret-bearing headers as `curl -H` arguments. ### Technical Analysis Command-line arguments are normally exposed through process inspection mechanisms such as `/proc/<pid>/cmdline`, process-monitoring software, audit logs, debugging tools, and commands such ...[truncated 1565 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not pass authentication headers through `curl -H` command-line arguments. - Reuse the safer implementation already present in `router.py:603-621`: 1. Create a temporary header file using a securely generated name. 2. Set its permissions to mode `0600`. 3. Write authentication headers to that file. 4. Invoke `curl` using its header-file/config-file support without putting the secret in argv. 5. Delete the file in a `finally` block. - Prefer a native HTTP client library that keeps headers in process memory rather than spawning `curl`. - Add an automated test that inspects the child process argument vector and verifies that no API key or authorization header is present. - Correct the blanket documentation claim that keys never appear in process listings until all affected utilities have been repaired. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
router.py:933
Finding
API Keys Accepted and Forwarded as Command-Line Arguments During Setup<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:24,31,53`; `install.sh:7,13,23`; `get-ai-router.sh:7-9`; `router.py:933-934,1004-1006` **Vulnerability Type**: Sensitive credential exposure through setup arguments and shell history **Risk Level**: Medium ### Vulnerable Code The router explicitly accepts an API key as the value of the `--setup` command-line option: ```python ap.add_argument('--setup', metavar='KEY', nargs='?', const='', help='install an API key: ai --setup <key> [--provider mistral]') ``` It then reads the key directly from the parsed process arguments: ```python if a.setup is not None: key = a.setup.strip() if not key: print(SETUP_HELP); return ``` The documented and scripted setup paths use commands equivalent to: ```bash bash install.sh <API_KEY> python3 router.py --setup <API_KEY> ``` `install.sh` also forwards the supplied key into another process, creating an additional argument-vector exposure. ### Technical Analysis Secrets supplied as command-line arguments can be retained in interactive shell history and exposed through process listings, audit records, terminal logging, job-control output, crash diagnostics, and process-monitoring systems. Although the credential file is subsequently written with mode `0600`, that protection does not address disclosure before the write occurs. Passing the key from one setup script to another process further increases the number of observable locations. The setup task only requires receiving a secret from the user; it does not require the secret to be part of the command line. ### Attack Path 1. The user follows the documented installation command and places an API key directly after `install.sh` or `--setup`. 2. The interactive shell records the command, unless history is explicitly disabled. 3. The installer forwards the key into the router process. 4. A local process observer, terminal logger, audit system, or later reader of the history fi ...[truncated 495 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace command-line key entry with one or more of the following: - A hidden interactive prompt using Python `getpass.getpass()`. - A `--setup-stdin` mode that reads the key from standard input. - A file-descriptor-based interface suitable for secret managers. - Do not forward keys as positional or option arguments between shell scripts and Python processes. - Remove examples containing `install.sh <API_KEY>` or `--setup <API_KEY>` from `SKILL.md` and installer help. - Preserve mode `0600` on credential files and create them atomically. - Warn existing users to remove past key-bearing commands from shell history and rotate keys that may have been exposed. - Add tests that verify setup works without the key appearing in `/proc/<pid>/cmdline`. ]]>

T08 · Insecure Dependencies

Warning
Location
get-ai-router.sh:13
Finding
Unpinned Remote Package Download and Execution<![CDATA[ ## Vulnerability Details **File Location**: `get-ai-router.sh:13-15`; `SKILL.md:23` **Vulnerability Type**: Mutable third-party package execution **Risk Level**: Medium ### Vulnerable Code The bootstrap workflow invokes the latest available version of a remote npm package: ```bash npx --yes clawhub@latest install free-tier-ai-router --no-input ``` The same unpinned installation workflow is recommended by the Skill documentation. ### Technical Analysis `npx` downloads and executes package code. The `@latest` selector is mutable and can resolve to different code at different times, including code published after this Skill was reviewed. The bundled router payload has a SHA-256 verification mechanism, but that checksum only applies to the bundled router content. It does not authenticate the `clawhub@latest` package that `npx` downloads and executes. This creates a supply-chain trust boundary outside the reviewed project. Compromise of the registry account, publication pipeline, package release, or transitive dependencies could result in arbitrary code execution under the invoking user's identity. ### Attack Path 1. An attacker compromises the `clawhub` package, its publisher account, release pipeline, or a dependency incorporated into a new release. 2. The malicious release becomes the version selected by the `latest` tag. 3. A user follows `SKILL.md` or executes `get-ai-router.sh`. 4. `npx` downloads the mutable package and executes its lifecycle or command code. 5. The malicious package operates with the user's filesystem, network, and credential-access privileges. ### Impact Assessment The downloaded package executes with the privileges of the user running the installer. It may therefore read or modify user-accessible files, access environment variables, make network requests, alter installed tools, or steal credentials available to that account. No malicious package behavior was confirmed in the audited artifact. The vulnerability is the ...[truncated 109 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace `clawhub@latest` with an exact reviewed version. - Pin and verify the package integrity value or lockfile metadata. - Verify package provenance or trusted release signatures where available. - Avoid suppressing installation failures when remotely obtained code is being executed. - Prefer distributing and invoking the reviewed local installer directly when remote package execution is unnecessary. - Include dependency and package-integrity review in the release process. - Re-review and deliberately update the pinned version rather than following a mutable distribution tag. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
get-ai-router.sh:21
Finding
Malformed Bootstrap Payload Extraction Prevents Verified Installation<![CDATA[ ## Vulnerability Details **File Location**: `get-ai-router.sh:21-26` **Vulnerability Type**: Broken security-critical bootstrap logic **Risk Level**: Medium ### Vulnerable Code The payload extraction command begins an `awk` program with an unmatched single quote: ```bash awk '/^#__PAYLOAD__ ``` The following lines contain payload data, but the shell construct has no valid closing quote, complete input selection, output redirection, or functional payload installation sequence. ### Technical Analysis Shell syntax is parsed before normal command execution. The unmatched quote makes the bootstrap script syntactically invalid, so it cannot reliably perform the documented checksum-verified installation. The defect undermines availability and the integrity expectations of the installation process. It may also prevent commands located earlier in the script from running, because the shell can reject the entire script during parsing. This issue is not evidence of malicious payload execution. It is an insecure implementation of a security-sensitive bootstrap mechanism. ### Attack Path 1. A user invokes `get-ai-router.sh`, expecting it to extract and verify the bundled payload. 2. The shell encounters the unterminated quoted `awk` expression. 3. Script parsing fails before the intended extraction, verification, and integration workflow completes. 4. The installation is left incomplete. 5. The user may resort to an unverified manual download or workaround, weakening the intended integrity controls. ### Impact Assessment The direct impact is denial of installation and failure of the promised checksum-verified bootstrap path. The defect does not itself grant an attacker additional operating-system privileges. Security impact can arise indirectly if users replace the failed workflow with unverified installation commands or artifacts. The affected scope is the installation process rather than normal router execution. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Replace the malformed expression with a syntactically complete payload-marker extraction command. - Extract the data after a unique marker into a securely created temporary file. - Parse the extracted JSON and decode the router payload. - Verify the decoded bytes against the expected SHA-256 before installing or executing them. - Abort on every extraction, parsing, decoding, or checksum error. - Write the verified payload to the intended destination and then invoke the integration workflow explicitly. - Add the following automated checks: - `bash -n get-ai-router.sh` - A clean-environment installation test. - A corrupted-payload test that must fail closed. - A checksum-mismatch test that confirms no artifact is installed. ]]>

T09 · Insecure Skill Coding Practices

Note
Location
router.py:81
Finding
Declared Network Permissions Understate Actual Provider Destinations<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:5`; `router.py:81-96,103-164,150-162,572-590`; `references/providers.md:1-31` **Vulnerability Type**: Incomplete network-capability declaration and unsafe custom endpoint configuration **Risk Level**: Low ### Relevant Code and Configuration The provider documentation explicitly permits user-defined endpoints and several key sources: ```json { "providers": { "my-lab-gateway": { "base_url": "http://127.0.0.1:18321/v1/", "auth": "none", "models": [ {"id": "big-70b", "quality": 5, "rpm": 600, "rpd": null, "tier": "cheap", "tags": "best-value"}, "tiny-1b" ] } } } ``` The supported credential configuration is documented as: ```text - `auth`: `bearer` (default) · `x-api-key` · `none` (local servers) - keys: inline `api_key`, or `key_file`, or the usual `~/.config/<name>/credentials.json` ``` The audited router also contains built-in destinations for: ```text api.groq.com api.llm7.io router.huggingface.co api.cohere.com ``` These destinations are not all represented in the five-host outbound declaration in `SKILL.md:5`. The custom-provider implementation additionally permits user-selected HTTP or HTTPS base URLs and can attach a configured key to requests sent to those URLs. ### Technical Analysis The metadata does not fully describe the router's actual network trust boundary. Reviewers relying on the declared host list may conclude that the Skill has a narrower outbound capability than its implementation provides. Custom endpoints are a legitimate extensibility feature, but they permit credentials to be sent to arbitrary user-configured destinations. If a configuration is malicious, tampered with, or mistaken, an API key can be transmitted to an attacker-controlled server. Allowing non-loopback plain HTTP endpoints would also expose credentials to network interception. Reading expected provider credentials and contacting provider API ...[truncated 1238 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Update Skill metadata to list every built-in provider host. - Explicitly document that custom providers require user-approved arbitrary network destinations. - Reject plain HTTP base URLs unless the destination is a verified loopback address. - Display a confirmation containing the exact hostname before sending credentials to a newly configured custom endpoint. - Bind each credential to an expected provider hostname and reject mismatched destinations by default. - Validate and permission-protect `~/.config/ai_router/providers.json`. - Avoid inline API keys where possible; prefer mode-0600 credential files. - Provide an allowlist mode for deployments that require a fixed network boundary. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Output HandlingUnvalidated Output Injection, Cross-Context Output, Unbounded Output
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (34)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
os.fchmod(fd, 0o600)
            with os.fdopen(fd, 'w') as fh:
                fh.write('\n'.join(hdr) + '\n')
            r = subprocess.run(['curl', '-sS', '--max-time', '20',
                                '-w', '\n__H__%{http_code}', '-H', f'@{hfile}',
                                base + '/models'], capture_output=True, text=True)
        finally:
Confidence
89% confidence
Finding
The code issues outbound requests to a user-configured `base_url` during discovery without restricting destination hosts. In an agent context, this can be abused as SSRF to probe internal services or reach attacker-chosen endpoints, especially because `providers.json` is explicitly user-extensible and `_normalize_base` accepts arbitrary HTTP/HTTPS URLs.

Tainted flow: 'base' from sys.stdin.read (line 691, user input) → subprocess.run (code execution)

Critical
Category
Data Flow
Content
os.fchmod(fd, 0o600)
            with os.fdopen(fd, 'w') as fh:
                fh.write('\n'.join(hdr) + '\n')
            r = subprocess.run(['curl', '-sS', '--max-time', '20',
                                '-w', '\n__H__%{http_code}', '-H', f'@{hfile}',
                                base + '/models'], capture_output=True, text=True)
        finally:
Confidence
92% confidence
Finding
A user-controlled or adversarially supplied `base_url` from configuration is concatenated into a request target and fetched by `curl`. Even without shell injection, this enables SSRF and internal network access from the host running the router, which is particularly dangerous for agent systems that may operate in sensitive environments.

Tp4

High
Category
MCP Tool Poisoning
Confidence
90% confidence
Finding
The advertised purpose is routing across providers, but the documentation also describes bootstrap installation, key registration and live verification, credential restoration from backups, self-healing upgrades, model discovery on arbitrary OpenAI-compatible endpoints, and persistent prompt caching. This broader behavior materially expands the trust boundary and attack surface, making it easier for users to grant more access than they intended.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The bootstrapper does more than install a package: it carries and writes an embedded payload that replaces or upgrades code on disk. That makes the installed behavior opaque to normal package provenance controls and increases supply-chain risk, because reviewers and users may assume they are only invoking a registry install while actually unpacking additional code from the script itself.

Context-Inappropriate Capability

Medium
Confidence
86% confidence
Finding
The script executes `npx clawhub@latest install ...`, which pulls and runs the latest remote package-manager code at install time. Using `@latest` creates an avoidable supply-chain execution path where future upstream compromise or malicious publication would run code on the user's machine during bootstrap.

Intent-Code Divergence

High
Confidence
93% confidence
Finding
The script claims it makes zero API calls, but later invokes `python3 "$ROUTER" --setup`, `--plan`, `--doctor`, and `--status`-style functionality that may perform live probing depending on router implementation. Misrepresenting network behavior is dangerous because operators may run the script in restricted or sensitive environments expecting no external communication, potentially causing unintended credential use, outbound requests, quota consumption, or data disclosure.

Description-Behavior Mismatch

Medium
Confidence
86% confidence
Finding
The integration script restores provider credential files from `~/cred_backup` into active config locations, which is behavior beyond simple workspace wiring and directly manipulates authentication material. In a skill context, silently reactivating stored API keys can surprise users, re-enable paid/external access, and expand the blast radius if backups are stale, unintended, or attacker-planted.

Intent-Code Divergence

Medium
Confidence
82% confidence
Finding
Although the credential discovery block itself is file-only, the nearby readiness flow executes router commands whose behavior may include probing models or providers, making the surrounding 'NO network' framing misleading. This can cause users to trust the script as offline-safe when it may actually trigger outbound activity during integration or post-check reporting.

Context-Inappropriate Capability

Medium
Confidence
87% confidence
Finding
The script automatically reads API keys from multiple provider credential files on disk and then uses them for outbound requests. In an agent-skill context, that is a meaningful security concern because it expands secret access beyond a single provider and can consume or expose credentials without explicit user consent.

Description-Behavior Mismatch

Medium
Confidence
97% confidence
Finding
The manifest openly presents itself as a "self-repair payload for integrate.sh" and embeds a full base64-encoded Python program plus a hash, which is more than inert router metadata. Even if intended for maintenance, bundling code-overwrite payloads inside a skill artifact increases the risk of unreviewed code replacement, persistence, or supply-chain abuse if the integration path applies it automatically.

Context-Inappropriate Capability

Medium
Confidence
96% confidence
Finding
A routing skill should not need to carry self-modifying or self-updating capability in its manifest to perform normal request routing. This broadens the trust boundary from "route LLM calls" to "replace local code/config on disk," which can be abused by a compromised package source or unsafe installer behavior.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The trigger phrases are broad enough to match common user troubleshooting language such as "all models failed" or generic rate-limit issues, which can cause the skill to activate outside its intended scope. Over-broad activation increases the chance of inappropriate tool selection, accidental execution in unrelated contexts, and unnecessary exposure of local routing logic or configured provider behavior.

Missing User Warnings

Medium
Confidence
82% confidence
Finding
The script creates directories, installs packages, and proceeds on failure with only minimal console messaging. While not directly malicious, this is unsafe from a user-consent perspective because it performs meaningful system changes without clear disclosure of what will be written or executed.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The script automatically reads local API credentials and immediately uses them to contact multiple third-party endpoints, effectively spending quota and disclosing account usage to external services without an explicit consent gate at runtime. In an agent-skill context, that is more dangerous because the skill may be invoked opportunistically and probe many providers the user did not intend to touch.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The script silently loads local API credentials and transmits prompts plus bearer tokens to several third-party endpoints. In a skill ecosystem, undisclosed secret use and multi-provider network transmission materially increase risk because users may not realize that installing or invoking the skill spends quota and shares data externally.

Missing User Warnings

Medium
Confidence
78% confidence
Finding
The script automatically reads API keys from standard credential files and immediately uses them to probe multiple third-party services, but it provides no consent prompt, scoping control, or warning about outbound authenticated requests. In an agent-skill context, implicit use of local secrets is risky because installing or invoking the skill can silently spend quota and expose account linkage across providers.

External Transmission

Medium
Category
Data Exfiltration
Content
body=json.dumps({'contents':[{'parts':[{'text':q}]}],'generationConfig':{'maxOutputTokens':2500}})
    else:
        url,key,extra={
         'mistral':('https://api.mistral.ai/v1/chat/completions',creds('mistral')['api_key'],[]),
         'openrouter':('https://openrouter.ai/api/v1/chat/completions',creds('openrouter')['api_key'],
                       ['HTTP-Referer: https://arena.ai','X-Title: ArenaAgentMode']),
         'kilo':('https://api.kilo.ai/api/gateway/chat/completions',creds('kilo')['api_key'],
Confidence
89% confidence
Finding
This code sends requests and credentials to an external API endpoint, which is the intended function of the script but still a real security-relevant data transmission. In context, the risk is elevated because the skill probes many models and may automatically consume local secrets and send data to remote services without explicit per-run approval.

External Transmission

Medium
Category
Data Exfiltration
Content
'mistral':('https://api.mistral.ai/v1/chat/completions',creds('mistral')['api_key'],[]),
         'openrouter':('https://openrouter.ai/api/v1/chat/completions',creds('openrouter')['api_key'],
                       ['HTTP-Referer: https://arena.ai','X-Title: ArenaAgentMode']),
         'kilo':('https://api.kilo.ai/api/gateway/chat/completions',creds('kilo')['api_key'],
                 ['X-KILOCODE-FEATURE: arena-agent']),
        }[prov]
        h=['Content-Type: application/json',f'Authorization: Bearer {key}']+extra
Confidence
89% confidence
Finding
This code transmits prompts and bearer credentials to another third-party endpoint. While expected for an LLM router, it remains a genuine security concern in agent environments because outbound transmission to multiple services broadens exposure and can incur unanticipated data-sharing or quota consumption.

External Transmission

Medium
Category
Data Exfiltration
Content
body=json.dumps({'contents':[{'parts':[{'text':'hi'}]}],'generationConfig':{'maxOutputTokens':800}})
    else:
        url,key,extra={
         'mistral':('https://api.mistral.ai/v1/chat/completions',creds('mistral')['api_key'],[]),
         'openrouter':('https://openrouter.ai/api/v1/chat/completions',creds('openrouter')['api_key'],
                       ['HTTP-Referer: https://arena.ai','X-Title: ArenaAgentMode']),
         'kilo':('https://api.kilo.ai/api/gateway/chat/completions',creds('kilo')['api_key'],
Confidence
87% confidence
Finding
The script transmits authenticated requests to external LLM providers using locally sourced API keys, which creates real outbound data flow and quota consumption. Although the payload is only 'hi', the skill context makes this more sensitive because it probes many providers/models automatically, multiplying secret use and external exposure without granular approval.

External Transmission

Medium
Category
Data Exfiltration
Content
'mistral':('https://api.mistral.ai/v1/chat/completions',creds('mistral')['api_key'],[]),
         'openrouter':('https://openrouter.ai/api/v1/chat/completions',creds('openrouter')['api_key'],
                       ['HTTP-Referer: https://arena.ai','X-Title: ArenaAgentMode']),
         'kilo':('https://api.kilo.ai/api/gateway/chat/completions',creds('kilo')['api_key'],
                 ['X-KILOCODE-FEATURE: arena-agent']),
        }[prov]
        h=['Content-Type: application/json',f'Authorization: Bearer {key}']+extra
Confidence
87% confidence
Finding
This line defines another external authenticated endpoint and participates in the same automatic multi-provider probing behavior. The danger is not the specific Kilo domain alone, but that the skill silently sends requests to third parties using discovered local credentials, which can spend quota and reveal service usage patterns.

Unvalidated Output Injection

High
Category
Output Handling
Content
os.fchmod(fd, 0o600)
            with os.fdopen(fd, 'w') as fh:
                fh.write('\n'.join(hdr) + '\n')
            r = subprocess.run(['curl', '-sS', '--max-time', '20',
                                '-w', '\n__H__%{http_code}', '-H', f'@{hfile}',
                                base + '/models'], capture_output=True, text=True)
        finally:
Confidence
88% confidence
Finding
Although there is no shell injection, unvalidated `base_url` output is used to form a network request destination. In practice this is an SSRF-style sink: attacker-influenced configuration can direct the process to internal or sensitive HTTP services and capture reachability or response metadata.

Credential Access

High
Category
Privilege Escalation
Content
name: free-tier-ai-router
description: Quota-aware LLM router that squeezes maximum usable AI out of free-tier API keys across Gemini, Mistral, OpenRouter, Kilo and Cerebras plus any OpenAI-compatible endpoint (including local Ollama/llama.cpp/vLLM). Probes every model on every key, measures real quality and real published rate limits, then routes each request to the cheapest model that can do the job — spending abundant capacity first and reserving scarce daily quota for when it is actually needed. Persists cooldowns to disk so a 429 discovered in one process is respected by the next. Use when an agent must make many LLM calls on free keys without hitting rate limits, when "all models failed", or when deciding which of several provider keys to use for a task.
version: 2.4.0.1
metadata: {"openclaw":{"emoji":"🎛️","requires":{"bins":["curl","python3"]},"configPaths":["~/.config/gemini/credentials.json","~/.config/mistral/credentials.json","~/.config/openrouter/credentials.json","~/.config/kilo/credentials.json","~/.cache/ai_router/state.json"],"network":{"outbound":["generativelanguage.googleapis.com","api.mistral.ai","openrouter.ai","api.kilo.ai","api.cerebras.ai"]}}}
topics: [llm-routing, free-tier, rate-limits, openai-compatible, providers]
---
Confidence
86% confidence
Finding
The skill documentation indicates credential files are used together with probing, live verification, and quota measurement. Automated test calls against multiple providers can unintentionally consume quota or transmit prompts to services the user did not fully intend to activate, which is a meaningful security and privacy concern around credential use.

Credential Access

High
Category
Privilege Escalation
Content
name: free-tier-ai-router
description: Quota-aware LLM router that squeezes maximum usable AI out of free-tier API keys across Gemini, Mistral, OpenRouter, Kilo and Cerebras plus any OpenAI-compatible endpoint (including local Ollama/llama.cpp/vLLM). Probes every model on every key, measures real quality and real published rate limits, then routes each request to the cheapest model that can do the job — spending abundant capacity first and reserving scarce daily quota for when it is actually needed. Persists cooldowns to disk so a 429 discovered in one process is respected by the next. Use when an agent must make many LLM calls on free keys without hitting rate limits, when "all models failed", or when deciding which of several provider keys to use for a task.
version: 2.4.0.1
metadata: {"openclaw":{"emoji":"🎛️","requires":{"bins":["curl","python3"]},"configPaths":["~/.config/gemini/credentials.json","~/.config/mistral/credentials.json","~/.config/openrouter/credentials.json","~/.config/kilo/credentials.json","~/.cache/ai_router/state.json"],"network":{"outbound":["generativelanguage.googleapis.com","api.mistral.ai","openrouter.ai","api.kilo.ai","api.cerebras.ai"]}}}
topics: [llm-routing, free-tier, rate-limits, openai-compatible, providers]
---
Confidence
86% confidence
Finding
The skill documentation indicates credential files are used together with probing, live verification, and quota measurement. Automated test calls against multiple providers can unintentionally consume quota or transmit prompts to services the user did not fully intend to activate, which is a meaningful security and privacy concern around credential use.

Credential Access

High
Category
Privilege Escalation
Content
name: free-tier-ai-router
description: Quota-aware LLM router that squeezes maximum usable AI out of free-tier API keys across Gemini, Mistral, OpenRouter, Kilo and Cerebras plus any OpenAI-compatible endpoint (including local Ollama/llama.cpp/vLLM). Probes every model on every key, measures real quality and real published rate limits, then routes each request to the cheapest model that can do the job — spending abundant capacity first and reserving scarce daily quota for when it is actually needed. Persists cooldowns to disk so a 429 discovered in one process is respected by the next. Use when an agent must make many LLM calls on free keys without hitting rate limits, when "all models failed", or when deciding which of several provider keys to use for a task.
version: 2.4.0.1
metadata: {"openclaw":{"emoji":"🎛️","requires":{"bins":["curl","python3"]},"configPaths":["~/.config/gemini/credentials.json","~/.config/mistral/credentials.json","~/.config/openrouter/credentials.json","~/.config/kilo/credentials.json","~/.cache/ai_router/state.json"],"network":{"outbound":["generativelanguage.googleapis.com","api.mistral.ai","openrouter.ai","api.kilo.ai","api.cerebras.ai"]}}}
topics: [llm-routing, free-tier, rate-limits, openai-compatible, providers]
---
Confidence
86% confidence
Finding
The skill documentation indicates credential files are used together with probing, live verification, and quota measurement. Automated test calls against multiple providers can unintentionally consume quota or transmit prompts to services the user did not fully intend to activate, which is a meaningful security and privacy concern around credential use.

Credential Access

High
Category
Privilege Escalation
Content
name: free-tier-ai-router
description: Quota-aware LLM router that squeezes maximum usable AI out of free-tier API keys across Gemini, Mistral, OpenRouter, Kilo and Cerebras plus any OpenAI-compatible endpoint (including local Ollama/llama.cpp/vLLM). Probes every model on every key, measures real quality and real published rate limits, then routes each request to the cheapest model that can do the job — spending abundant capacity first and reserving scarce daily quota for when it is actually needed. Persists cooldowns to disk so a 429 discovered in one process is respected by the next. Use when an agent must make many LLM calls on free keys without hitting rate limits, when "all models failed", or when deciding which of several provider keys to use for a task.
version: 2.4.0.1
metadata: {"openclaw":{"emoji":"🎛️","requires":{"bins":["curl","python3"]},"configPaths":["~/.config/gemini/credentials.json","~/.config/mistral/credentials.json","~/.config/openrouter/credentials.json","~/.config/kilo/credentials.json","~/.cache/ai_router/state.json"],"network":{"outbound":["generativelanguage.googleapis.com","api.mistral.ai","openrouter.ai","api.kilo.ai","api.cerebras.ai"]}}}
topics: [llm-routing, free-tier, rate-limits, openai-compatible, providers]
---
Confidence
86% confidence
Finding
The skill documentation indicates credential files are used together with probing, live verification, and quota measurement. Automated test calls against multiple providers can unintentionally consume quota or transmit prompts to services the user did not fully intend to activate, which is a meaningful security and privacy concern around credential use.

Static analysis

Detected: suspicious.install_untrusted_source

Install source points to URL shortener or raw IP.

Warn
Code
suspicious.install_untrusted_source
Location
schema/providers.config.schema.json:25