OpenAI-compatible

Use OpenClaw with IteraCompute

Build text and read-only tool workflows.

Connect in three steps

1. Create an API key

Create or sign in to your IteraCompute account, then create a key in the Console.

2. Configure the base URL

Add an iteracompute provider with openai-completions and an environment-backed SecretRef. Use the full provider/model reference inside OpenClaw.

3. Select the model

Use the exact API Model ID for your chosen model. Check its context and capabilities before enabling agent or vision features.

Choose your model

DeepSeek V4.1 Flash 1017 is the paid reference model. You can replace it with a published conversation model allowed by your key. Recheck model permissions, prices, context and tool support after switching; the examples follow your selection, while the retained test results remain tied to Qwen.

Prepare an isolated environment

Install OpenClaw 2026.11.1 in a separate directory. The retained agent tests used Bun 1.4.4; keep configuration and state isolated.

Bash / macOS / Linux / WSL
# Node: >=24.16.0 <25 or >=26.1.0; npm <=11.15
node --version
npm --version
umask 077
mkdir -p itera-openclaw-demo
cd itera-openclaw-demo
export ITERA_RUNTIME="$PWD/runtime"
npm install --prefix "$ITERA_RUNTIME" openclaw@2026.11.1 bun@1.4.4 \
  --no-audit --no-fund
export BUN="$ITERA_RUNTIME/node_modules/.bin/bun"
export OPENCLAW_ENTRY="$ITERA_RUNTIME/node_modules/openclaw/openclaw.mjs"
"$BUN" --version
"$BUN" "$OPENCLAW_ENTRY" --version
mkdir -p workspace state home
export OPENCLAW_HOME="$PWD/home"
export OPENCLAW_STATE_DIR="$PWD/state"
export OPENCLAW_CONFIG_PATH="$PWD/openclaw.iteracompute.json"
export OPENCLAW_OFFLINE=1
Bash · key in the current terminal
umask 077
read -rsp 'IteraCompute API key: ' ITERACOMPUTE_API_KEY
printf '\n'
export ITERACOMPUTE_API_KEY

The install command targets npm 11.15 or earlier; npm 11.16+ / 12 requires the current official --allow-scripts=openclaw install option. The explicit Bun entry matches the retained successful runtime. OPENCLAW_OFFLINE prevents helper downloads, not model API calls. No daemon or messaging account is required.

Example configuration

Keep API keys in your server environment or tool credential store. Replace the example key field with your own key where applicable.

openclaw.iteracompute.json
{
  "models": {
    "mode": "replace",
    "providers": {
      "iteracompute": {
        "baseUrl": "https://api.iteracompute.com/v1",
        "api": "openai-completions",
        "apiKey": {
          "source": "env",
          "provider": "default",
          "id": "ITERACOMPUTE_API_KEY"
        },
        "timeoutSeconds": 180,
        "models": [
          {
            "id": "deepseek/deepseek-v4.1-flash-1017",
            "name": "DeepSeek V4.1 Flash 1017",
            "reasoning": true,
            "input": [
              "text"
            ],
            "contextWindow": 1048576,
            "contextTokens": 110000,
            "maxTokens": 512,
            "compat": {
              "maxTokensField": "max_tokens",
              "supportsReasoningEffort": false,
              "supportsUsageInStreaming": true
            }
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "iteracompute/deepseek/deepseek-v4.1-flash-1017",
        "fallbacks": []
      },
      "modelPolicy": {
        "allow": [
          "iteracompute/deepseek/deepseek-v4.1-flash-1017"
        ]
      },
      "models": {
        "iteracompute/deepseek/deepseek-v4.1-flash-1017": {
          "alias": "itera-model",
          "params": {
            "maxTokens": 512,
            "extraBody": {}
          }
        }
      },
      "thinkingDefault": "off",
      "skipBootstrap": true,
      "contextInjection": "never"
    }
  },
  "tools": {
    "deny": [
      "*"
    ],
    "toolSearch": false
  },
  "plugins": {
    "enabled": false
  }
}

Save this configuration only in the isolated profile created above. These Chat Completions examples start with 512 output tokens and no fallback. Context metadata is not an account entitlement; OpenClaw uses a smaller input budget. The Qwen selection uses 128K account context. Reasoning controls vary by model: the Python and OpenClaw examples add reasoning: false only for Qwen; do not transfer that option to other models.

Check the direct API first

Python · direct text check
python3 - <<'PY'
import json
import os
import urllib.error
import urllib.request
payload = {
    'model': 'deepseek/deepseek-v4.1-flash-1017',
    'messages': [{'role': 'user', 'content': 'Reply with exactly: ITERACOMPUTE_API_OK'}],
    'max_tokens': 512,
    **{},
}
request = urllib.request.Request(
    'https://api.iteracompute.com/v1/chat/completions',
    data=json.dumps(payload).encode('utf-8'),
    headers={'Authorization': 'Bearer ' + os.environ['ITERACOMPUTE_API_KEY'],
             'Content-Type': 'application/json'}, method='POST',
)
try:
    with urllib.request.urlopen(request, timeout=180) as response:
        result = json.load(response)
except urllib.error.HTTPError as exc:
    raise SystemExit(f'HTTP {exc.code}; inspect redacted details privately') from None
except (urllib.error.URLError, TimeoutError):
    raise SystemExit('Network or timeout failure; no automatic retry') from None
choice = result['choices'][0]
if ((choice.get('message', {}).get('content') or '').strip() != 'ITERACOMPUTE_API_OK'
        or choice.get('finish_reason') != 'stop'):
    raise SystemExit('FAIL: expected final marker and stop reason not returned')
print('Direct API text passed; test the agent separately')
PY

This sends one real request when you run it. Confirm the exact visible marker and finish_reason=stop; an empty HTTP 200 response is incomplete. Paid model calls consume API balance. Do not automatically retry an unknown outcome.

Check the agent text path

Bash · text check
"$BUN" "$OPENCLAW_ENTRY" config validate --json
"$BUN" "$OPENCLAW_ENTRY" models list --provider iteracompute --json
"$BUN" "$OPENCLAW_ENTRY" agent exec \
  'Reply with exactly OPENCLAW_ITERACOMPUTE_TEXT_OK. Do not use tools.' \
  --config "$OPENCLAW_CONFIG_PATH" --cwd "$PWD/workspace" \
  --model iteracompute/deepseek/deepseek-v4.1-flash-1017 --code-mode direct \
  --thinking off --timeout 360 --json > text-result.private.json

python3 - <<'PY'
import json
from pathlib import Path
r = json.loads(Path('text-result.private.json').read_text(encoding='utf-8'))
if not (r.get('ok') is True and r.get('provider') == 'iteracompute'
        and r.get('model') == 'deepseek/deepseek-v4.1-flash-1017'
        and (r.get('final') or '').strip() == 'OPENCLAW_ITERACOMPUTE_TEXT_OK'):
    raise SystemExit('FAIL: inspect redacted details privately')
print('OpenClaw text invocation passed')
PY

Run the direct API check below first, then require a non-empty final marker, the intended provider/model and a clean exit from the agent. Configuration validation and a provider probe do not prove an agent or tool workflow.

Verify one tool round trip

After the text check passes, this script copies the text configuration and replaces the entire tools policy with workspace-only read access. It removes deny: ["*"]; a deny rule would override allow. The random marker is written only to the file, never to the prompt.

Bash · read tool and assertions
python3 - <<'PY'
import json
import secrets
from pathlib import Path
config = json.loads(Path('openclaw.iteracompute.json').read_text(encoding='utf-8'))
config['tools'] = {
    'allow': ['read'], 'fs': {'workspaceOnly': True}, 'toolSearch': False,
}
Path('openclaw.iteracompute.tools.json').write_text(json.dumps(config), encoding='utf-8')
Path('workspace/integration-marker.txt').write_text(
    'OPENCLAW_ITERACOMPUTE_TOOL_' + secrets.token_hex(8) + '\n', encoding='utf-8')
PY

"$BUN" "$OPENCLAW_ENTRY" agent exec \
  'Use read to read integration-marker.txt, then reply with exactly the marker in that file. Do not guess or use other tools.' \
  --config "$PWD/openclaw.iteracompute.tools.json" --cwd "$PWD/workspace" \
  --model iteracompute/deepseek/deepseek-v4.1-flash-1017 --code-mode direct \
  --thinking off --timeout 600 --json > tool-result.private.json

python3 - <<'PY'
import json
from pathlib import Path
r = json.loads(Path('tool-result.private.json').read_text(encoding='utf-8'))
expected = Path('workspace/integration-marker.txt').read_text(encoding='utf-8').strip()
tools = r.get('toolSummary') or {}
checks = [r.get('ok') is True, r.get('provider') == 'iteracompute',
          r.get('model') == 'deepseek/deepseek-v4.1-flash-1017', tools.get('calls') == 1,
          tools.get('tools') == ['read'], tools.get('failures') == 0,
          r.get('assistantTurns') == 2, (r.get('final') or '').strip() == expected]
if not all(checks):
    raise SystemExit('FAIL: inspect redacted details privately')
print('OpenClaw read tool loop passed')
PY

Success criterion: the configured provider/model, exactly one successful read call, two assistant turns and a final reply matching the file marker. A model saying it read a file is insufficient.

Version and verification

Tested version
OpenClaw 2026.11.1 · Bun 1.4.4
Result
Text and read-only tools passed.

Credentials, tools and data

The model API runs remotely; no local GPU or public Gateway port is needed. The agent still needs local CPU, memory and permissions. Keep keys in the launching process environment, keep raw logs private, and enable only the tools needed for your test. External tools and services have their own setup and costs.

Test the connection

cURL · Chat Completions
# Bash / zsh / WSL; set ITERACOMPUTE_API_KEY in your environment first.
curl --fail-with-body https://api.iteracompute.com/v1/chat/completions \
  -H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"deepseek/deepseek-v4.1-flash-1017","messages":[{"role":"user","content":"Reply with exactly: Hello!"}],"max_tokens":512}'

Check that choices[0].message.content contains visible text; HTTP 200 alone is insufficient. Reasoning may consume the output budget. For free Auto, use the first free call example to disable thinking, then send a prompt inside your tool.

Selected model capabilities

Capabilities describe the IteraCompute API. Feature availability in your workflow also depends on the tool and its settings; reasoning controls vary by model.

  • Chat CompletionsSupported
  • Tool callingSupported
  • ReasoningSupported
  • Image inputSupported
  • StreamingSupported

Troubleshooting

401 / 403 / 404

Check the launching process key, model permission and paid balance. Keep /v1 once in the base URL. Send the raw Model ID to the API; the iteracompute/ prefix belongs only to OpenClaw routing.

400 / Empty reply / 429

Check model-specific reasoning parameters, output budget and account limits. Honor Retry-After. Do not stack reasoning dialects, infer success from HTTP 200 or switch to another paid model automatically.

Tool missing / Wrong profile

Hermes: disable tool_search for the todo test and keep Python and CLI profiles separate. OpenClaw: replace deny-all with read-only for the tool test; do not use --isolated or --auth-env-only with this custom config.

OpenClaw configuration reference →

Start building with OpenClaw.

Connect your key, choose a model and send your first request.