Developer documentation

1. Choose your runtime

A deployment starts with an authorized account, a defined workload and an operator responsible for access, costs and data handling. This guide provides an integration starting point; it does not provision infrastructure.

Use Python 3.10 or later. Create a virtual environment and install the actual provider libraries:

python -m venv .venv
# Activate .venv using the command for your operating system.
python -m pip install boto3 requests

boto3 is the AWS Python SDK. requests is a Python HTTP client. Neither is a DAOCALM SDK. Pin versions that you have tested with your deployment before a production release.

2. Nexus Multi-Agent API integration

The reference integration coordinates multiple specialist model calls through Amazon Bedrock Converse. The downloadable helper runs two independent reviews and a final synthesis. It executes no generated code and connects to no external tools or memory store.

Prerequisites and credentials

• Select an AWS region and a model or inference profile that your account can access and that supports Converse.
• Authorize the calling identity for bedrock:InvokeModel on the selected resources. Model availability and applicable provider requirements must be checked for that account.
• Configure credentials through a supported AWS SDK credential provider, such as an authorized role or AWS profile. Keep credentials out of browser code, workflow exports and website forms.
• Set AWS_REGION and BEDROCK_MODEL_ID, or pass the corresponding command-line options to the helper.

See the AWS SDK credential guide and Bedrock endpoints and quotas.

REST endpoint and request headers

POST https://bedrock-runtime.{region}.amazonaws.com/model/{modelId}/converse. Replace the region and URL-encode the selected model identifier in the path. The following wire-format example uses the US East (N. Virginia) hostname. Its signing values are placeholders; use the Python SDK below to produce a correctly signed request.

POST /model/{URL_ENCODED_MODEL_ID}/converse HTTP/1.1
Host: bedrock-runtime.us-east-1.amazonaws.com
Content-Type: application/json
X-Amz-Date: {UTC_TIMESTAMP}
X-Amz-Security-Token: {TEMPORARY_SESSION_TOKEN_IF_USED}
Authorization: AWS4-HMAC-SHA256 Credential={ACCESS_KEY_ID}/{DATE}/us-east-1/bedrock/aws4_request, SignedHeaders={SIGNED_HEADER_NAMES}, Signature={SIGNATURE}

{
  "system": [{"text": "Review requirements. Identify missing information."}],
  "messages": [{
    "role": "user",
    "content": [{"text": "Outline a review process for an internal support assistant."}]
  }],
  "inferenceConfig": {"maxTokens": 800}
}

The X-Amz-Security-Token header applies when using temporary credentials. AWS Signature Version 4 signs the request using the appropriate credential provider; a DAOCALM website password is not an AWS credential. AWS request signing reference.

Request fields

The provider's complete supported fields and response contract are documented in the Bedrock Converse API reference.

JSON response example

Illustrative successful provider response. Text, token counts and latency vary with each request.

{
  "output": {
    "message": {
      "role": "assistant",
      "content": [{"text": "Define an owner, an escalation path and an evaluation set."}]
    }
  },
  "stopReason": "end_turn",
  "usage": {"inputTokens": 46, "outputTokens": 19, "totalTokens": 65},
  "metrics": {"latencyMs": 720}
}

Read text blocks from output.message.content and retain stopReason. A token limit, tool request or safety intervention needs different handling from an ordinary completed answer. Usage and latency are provider measurements; they do not establish a DAOCALM service guarantee. Converse request and response guide.

Python SDK call

import os
import boto3
from botocore.config import Config

client = boto3.client(
    "bedrock-runtime",
    region_name=os.environ["AWS_REGION"],
    config=Config(
        connect_timeout=5,
        read_timeout=120,
        retries={"mode": "standard", "total_max_attempts": 3},
    ),
)
response = client.converse(
    modelId=os.environ["BEDROCK_MODEL_ID"],
    system=[{"text": "Review the brief and identify missing requirements."}],
    messages=[{"role": "user", "content": [{"text": "Design a support triage pilot."}]}],
    inferenceConfig={"maxTokens": 800},
)
print(response["output"]["message"]["content"])
print(response["stopReason"], response["usage"])

The SDK resolves credentials and signs the request. See the Python Converse reference.

Bounded multi-agent example

Download nexus_bedrock.py, prepare a UTF-8 brief.txt and run it with your account's real region and model. The helper limits input to 12,000 characters and concurrent specialist calls to two. Its final JSON contains each review, the synthesis, provider usage and request identifiers.

python nexus_bedrock.py \
  --region YOUR_REGION \
  --model YOUR_MODEL_ID \
  --input brief.txt \
  --output nexus-result.json \
  --workers 2

Each invocation performs two specialist requests followed by one synthesis request. Set --workers 1 to serialize the specialist calls. The helper's local_run_id is a local trace identifier, not a remotely queryable Nexus job ID. Add durable job storage, tenant isolation, approved tool access and human approvals when scoping a production system.

Errors and retry behavior

The helper uses standard SDK retry behavior with at most three total attempts per model call. Its network timeouts apply per attempt, not to the complete multi-agent run. It does not automatically restart a failed overall job. AWS SDK retry configuration.

3. CineSynth Pipeline API integration

The reference integration submits a validated media workflow to a customer-configured ComfyUI runtime. A workflow defines its models, nodes, inputs and outputs. Script planning, approved brand assets, generation, consistency review and export must be configured and tested for the selected production pipeline.

Prerequisites and workflow export

1. Install and validate the required models and trusted nodes on the runtime. Confirm hardware capacity, model licenses and source-asset permissions.
2. Run a small test successfully in the ComfyUI interface.
3. Use File → Export (API) to save the working graph as workflow_api.json. A visual editor graph with layout metadata is a different format.
4. Keep the runtime on loopback or behind your configured access controls. Use HTTPS for a remote connection.

The API export maps node IDs to their class_type and inputs. There is no universal CineSynth workflow JSON that can guarantee video, a particular resolution or compatibility with every model. The official ComfyUI example documents the API export format.

Base URL and authentication

The local examples use http://127.0.0.1:8188, which means a ComfyUI runtime on the machine running the client. For a remote server, use the exact HTTPS address supplied by its operator. The DAOCALM website is not that runtime.

Send Content-Type: application/json for the submission body and Accept: application/json for JSON responses. If your gateway explicitly uses Bearer authentication, add Authorization: Bearer {YOUR_GATEWAY_TOKEN}. This is a gateway configuration, not a universal ComfyUI header or a DAOCALM API key. Adapt the helper for client certificates or another authentication scheme if required by your operator.

Runtime routes

See ComfyUI's official server routes. These routes describe a self-hosted runtime; a hosted cloud product can use a different contract.

Submit an actual exported workflow

The following commands wrap your exported graph in the real /prompt request envelope, then send it to your local runtime. The envelope's client_id identifies the client; it does not guarantee that repeated submissions will be deduplicated.

python - <<'PY'
import json
import uuid
from pathlib import Path

workflow = json.loads(Path("workflow_api.json").read_text(encoding="utf-8"))
payload = {"prompt": workflow, "client_id": str(uuid.uuid4())}
Path("prompt-request.json").write_text(json.dumps(payload), encoding="utf-8")
PY

curl --fail-with-body --connect-timeout 5 --max-time 30 \
  --request POST 'http://127.0.0.1:8188/prompt' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json' \
  --data-binary @prompt-request.json

Illustrative HTTP 200 acceptance response. Acceptance means queued, not rendered.

{
  "prompt_id": "6fecc520-3480-4cc4-8c64-3a6407a20aba",
  "number": 12,
  "node_errors": {}
}

Save prompt_id immediately. A validation failure can return error and node_errors; inspect the installed node types, connections, model names and required assets. Preserve the actual response and runtime logs in your restricted troubleshooting records.

Poll status, then retrieve output

GET /history/6fecc520-3480-4cc4-8c64-3a6407a20aba HTTP/1.1
Host: 127.0.0.1:8188
Accept: application/json

Illustrative history response, showing a still-frame output for clarity. The exact output schema depends on the workflow and output nodes.

{
  "6fecc520-3480-4cc4-8c64-3a6407a20aba": {
    "outputs": {
      "9": {
        "images": [{
          "filename": "preview_00001_.png",
          "subfolder": "",
          "type": "output"
        }]
      }
    },
    "status": {"status_str": "success", "completed": true, "messages": []}
  }
}

An empty object is not proof of success or failure: the job may be queued, running, expired or unknown. The helper waits for a successful completed record and detects reported execution errors. It stops waiting after the configured timeout; it does not cancel a server job.

curl --fail-with-body --get 'http://127.0.0.1:8188/view' \
  --header 'Accept: */*' \
  --data-urlencode 'filename=preview_00001_.png' \
  --data-urlencode 'subfolder=' \
  --data-urlencode 'type=output' \
  --output preview.png

Use filenames and folders from the real history response. The official history and artifact example demonstrates these parameters. Check your installed runtime's server implementation when integrating version-specific output behavior.

Python client with a polling timeout

Download cinesynth_comfyui.py into your working directory. This Python HTTP helper submits once, records the task ID, waits for completion and streams compatible output files. It recognizes file metadata in output arrays; video nodes with a different schema require an adapter.

python cinesynth_comfyui.py \
  --workflow workflow_api.json \
  --base-url http://127.0.0.1:8188 \
  --output-dir cinesynth-output \
  --timeout 900

You can also import its client. This example prints returned file metadata; use the command-line helper above for bounded downloads:

import json
import os
from pathlib import Path
from cinesynth_comfyui import ComfyClient, artifact_descriptors

workflow = json.loads(Path("workflow_api.json").read_text(encoding="utf-8"))
client = ComfyClient(
    os.environ.get("COMFY_BASE_URL", "http://127.0.0.1:8188"),
    token=os.environ.get("COMFY_GATEWAY_BEARER_TOKEN"),
)
prompt_id = client.submit(workflow)
print("Save this prompt ID:", prompt_id, flush=True)
history = client.wait(prompt_id, timeout=900)
for artifact in artifact_descriptors(history):
    print(artifact)

The default download limits are 512 MiB per artifact and 20 artifacts. Existing output directories are not replaced. Request timeouts bound individual connection and read waits; polling has its own deadline. Review history files before sharing them because they can include workflow inputs.

Resume and recover safely

If polling times out, read job.json and resume with the same runtime and authentication, using a new output directory:

python cinesynth_comfyui.py \
  --prompt-id YOUR_PROMPT_ID \
  --base-url http://127.0.0.1:8188 \
  --output-dir resumed-output \
  --timeout 900

• Submission timeout: inspect the runtime queue and history before sending another POST. The first submission may already have been accepted.
• HTTP 401 or 403: check the configured gateway or access policy with the operator.
• HTTP 400 or node validation errors: fix the exported graph, inputs, missing models or installed nodes.
• Read-only polling failures: the helper retries connection errors and HTTP 429/502/503/504 within its polling deadline.
• Execution failure: inspect the specific prompt's logs; check resources and workflow compatibility before a deliberate retry.
• Missing downloadable output: inspect the saved history and output-node contract. A completed workflow does not necessarily expose media in the supported format.

The helper does not issue queue-clearing or global interruption commands, which may affect other work on a shared runtime.

4. Production integration checklist

The examples do not promise eight-agent concurrency, 4K output, provider capacity or a particular completion time. Those depend on the agreed implementation and the configured runtime. Untrusted workflows and custom nodes can run code or contact external services; review them before installation or execution.

To discuss a prospective early pilot, request early access with your company, intended workload, preferred deployment, estimated volume and relevant data restrictions. This helps us scope initial development; the request does not create a workspace or issue credentials. Never submit passwords, API keys or confidential datasets through the inquiry form. Any agreed work and data handling are covered by our Terms of Service, Privacy Policy and the applicable written agreement.

5. Download the integration examples

• Nexus: AWS SDK orchestration helper (.py) — bounded specialist calls, synthesis, usage records and error handling.
• CineSynth: ComfyUI HTTP client (.py) — submission, finite polling, resume support and artifact downloads.
• Setup, assumptions and validation notes (.txt).

Documentation reviewed October 24, 2026 against the linked official references. The examples have been checked locally without billable inference or GPU execution. A live model call or render still requires your configured and authorized infrastructure.

Integration questions: [email protected] · Contact DAOCALM.