From one request.
To a working system.

Integration starts with a business outcome: the input, the deliverable and the acceptance criteria. Design generation, image-to-3D and metric production share a calling pattern, but have different standards for their outputs.

1. 01

   Choose a capability

   Define input and output for your task.

2. 02

   Submit a task

   Create a server-side request and retain its task ID.

3. 03

   Use the result

   Handle terminal states and validate artifacts before use.

# Set the agreed base URL and a server-side credential first.
# The .invalid host is a placeholder, not a live service.
export IDENIFE_BASE_URL="https://api.example.invalid"
export IDENIFE_API_KEY="<server-side-credential>"

curl --request POST "$IDENIFE_BASE_URL/v1/tasks" \
  --header "Authorization: Bearer $IDENIFE_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "capability": "design.generate",
  "input": {
    "prompt": "Design a low, elegant electric GT in liquid silver.",
    "constraints": {
      "view": "front_three_quarter",
      "material": "satin_metal"
    }
  },
  "output": {
    "format": "png"
  }
}'

The browser owns the experience; your backend owns identity, permissions and API calls. Have the frontend call your application service, which connects to the model with centrally managed credentials and access scopes.

Also agree how credentials are issued and rotated, whether access is project-scoped and how limits are reported. The Bearer example does not imply that every deployment uses the same authentication setup.

Separate capability selection, input conditions and output requirements. Your backend can share task-management logic while each capability keeps its own validation and acceptance criteria.

Pass images and datasets through agreed asset references. Check size, media type, access lifetime and data permissions before task creation. A generated 3D mesh is not the same as a parametric CAD solid.

Separate longer jobs into submission, observation and result retrieval. The interface need not block: the task ID connects the business record, execution state and final artifact.

// Illustrative server-side TypeScript; adapt to the agreed contract.
async function waitForTask(taskId: string, signal: AbortSignal) {
  const baseUrl = process.env.IDENIFE_BASE_URL;
  const key = process.env.IDENIFE_API_KEY;
  if (!baseUrl || !key) throw new Error("Missing configuration");

  for (let attempt = 0; attempt < 20; attempt++) {
    signal.throwIfAborted();
    const response = await fetch(
      baseUrl + "/v1/tasks/" + encodeURIComponent(taskId),
      { headers: { Authorization: "Bearer " + key }, signal }
    );
    if (!response.ok) throw new Error("HTTP " + response.status);
    const task = await response.json();
    if (task.status === "succeeded") return task.result;
    if (["failed", "cancelled"].includes(task.status)) {
      throw new Error(task.error?.code ?? task.status);
    }
    await new Promise<void>((resolve, reject) => {
      const stop = () => {
        clearTimeout(timer);
        reject(signal.reason);
      };
      const timer = setTimeout(() => {
        signal.removeEventListener("abort", stop);
        resolve();
      }, 1500);
      signal.addEventListener("abort", stop, { once: true });
    });
  }
  throw new Error("Polling budget exceeded; preserve taskId");
}

Applications should not guess completion from free-form text. Separate state, artifacts and errors so rendering, archiving, retries and human follow-up have an explicit basis.

{
  "task_id": "task_demo_design_001",
  "status": "succeeded",
  "result": {
    "artifacts": [
      {
        "id": "asset_demo_001",
        "type": "image",
        "format": "png",
        "uri": "asset://demo/electric-gt.png"
      }
    ],
    "capability": "design.generate"
  },
  "request_id": "req_demo_001"
}

artifacts

Read outputs through artifact descriptors: format, type and access location. The example asset:// reference is a placeholder, not a download URL.

error.code

Branch on stable error codes and show appropriate user messages. Avoid parsing human-readable error text for control flow.

retryable

Indicates whether this failure is suitable for retry; still consider business state, retry budget and the API contract.

HTTP status and retry semantics: RFC 9110

Model APIs invoke capabilities. MCP exposes tools and resources through a protocol. ID Axis organises reasoning and execution. They work together, with different responsibilities.

A successful response is the beginning. Production integration also needs agreements on access, failures, artifacts and observability so the capability can keep working in your environment.

Illustrative contract version: illustrative-v1