Developers · Tools and agents

The model proposes. Your application decides.

No tool runs without your code and your rules.

Language models can suggest actions, but they cannot be trusted to authorise them. Adil Edge is designed so that a model's tool call is only ever a request: the gateway and SDKs return it to your application and never execute it.

Current status

Tool calling is not available yet.

Not yet available

  • Adil Eco can emit tool calls in a structured format
  • Tool calling through the SDK is under repair and qualification, and is not available
  • Adil Eco V1.1 will support tool_choice set to auto or none only; tool_choice set to required will not be supported and will return an explicit capability error
  • No release will describe tool calling as working until it has passed qualification on the release model

Responsible execution and tool permissions

Rules for any tool your application exposes.

The gateway never executes tools
Tool calls are returned to your application as untrusted data. Neither the gateway nor the SDKs can run them, and the runtime's built-in tools are switched off.
Your application decides
Only your code can run a tool, and only after its own permission checks.
Allow-lists
Expose only the tools a task needs, and reject any call to a tool that is not on the list.
Schema validation
Validate every argument against the tool's schema before use; reject malformed or unexpected arguments rather than repairing them.
User confirmation
Ask the user to confirm any action that changes data, spends money, sends a message or cannot be undone.
Least privilege
Run tools with the narrowest permissions and data access that the task requires.

Payments, refunds, access control and safety-critical actions must never be authorised by generated output alone.

WEATHER_SCHEMA = {"type": "object", "properties": {"city": {"type": "string"}},
                  "required": ["city"], "additionalProperties": False}
weather = Tool("get_weather", "Current weather for a city", WEATHER_SCHEMA)
ALLOWED = {"get_weather"}                        # your allow-list

r = client.chat(history, tools=[weather])
for call in r.tool_calls:                        # model output: untrusted
    if call.name not in ALLOWED:
        continue                                 # reject tools not on the list
    args = call.parse_arguments()                # invalid JSON raises ValueError
    validate(args, WEATHER_SCHEMA)               # your schema check
    if not user_confirms(call.name, args):       # your confirmation step
        continue
    result = my_weather_lookup(args["city"])     # YOUR code runs the tool
Python: the host application validates, allow-lists, confirms and runs the tool. Illustrative only: tool calling is under repair and not available; validate() and user_confirms() stand for your own code.

Agent integration

MCP and A2A: planned.

Planned

Support for the Model Context Protocol (MCP) and the Agent2Agent (A2A) protocol is planned. It is not implemented or released, and no date has been set. Any future integration will follow the same rule: the model proposes, and the host application decides.

Integration with WorQ Agent Fabric through MCP and A2A is also planned. It is not an active production capability, and Adil Edge does not require it.