Coding agents

A single "fix this failing test" task can take 10 to 50 model calls: read files, search, run the tests, edit, run them again. Sending every call to the strongest model is slow and expensive; sending every call to a cheap model fails on the hard steps. And an agent stuck in a loop keeps spending until something stops it.

Tool calling uses the standard OpenAI tools and tool_calls fields, so agent frameworks that speak the OpenAI format work unchanged. Because every model sits behind the same key, the agent can use one model to plan and another to execute without a second account or SDK.

Match the model to the step, not the task. Check current per-token prices and context windows in the model catalog; the roles below hold even as the specific models change.

A minimal agent with one tool and a hard limit on steps. The limit matters: it is the first line of defence against a loop, before the key's spend cap.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://neurongate.net/v1",
    api_key=os.environ["NEURONGATE_API_KEY"],
)
import json
from pathlib import Path

tools = [{
    "type": "function",
    "function": {
        "name": "read_file",
        "description": "Read a file from the repository",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"],
        },
    },
}]

messages = [
    {"role": "system", "content": "You are a coding agent. Read files before answering."},
    {"role": "user", "content": "Why does tests/test_parse.py fail?"},
]

for step in range(10):  # hard cap on agent steps
    reply = client.chat.completions.create(
        model="~anthropic/claude-sonnet-latest",
        messages=messages,
        tools=tools,
    )
    msg = reply.choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        path = json.loads(call.function.arguments)["path"]
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": Path(path).read_text()[:20_000],  # bound what goes back in
        })

1. 1

   Give the workload its own key

   Create a key just for the agent under API keys. Its usage then shows up separately in the logs, and revoking it touches nothing else.
2. 2

   Set a monthly spend cap

   Once the key has spent its cap for the month, its requests are refused until the next month or until you raise the cap. Size it from a week of real traffic, not a guess.
3. 3

   Allowlist the models it may call

   Restrict the key to the models this workload actually uses, for example ~anthropic/claude-sonnet-latest and deepseek/deepseek-v4-flash. A typo or a prompt-injected model switch then fails instead of quietly running on a pricier model.
4. 4

   Watch the logs

   Filter the request log by this key to see tokens, cost and latency per call. Export CSV for a monthly cost-per-workload report.