DevelopersBuild with ArclodeOne REST API and native SDKs — a Rust core wrapped forSwift, Kotlin, Node, and Python — over a distributed inference network. Every binding wraps the same hand-written core, so no surface drifts from the wire.What you integrateArclode is one wire contract — the gateway's REST + SSE + WebSocket surface — with a native SDK for every runtime that matters. The HTTP, auth-header, streaming, and retry logic lives once, in the hand-written Rust core; the Swift and Kotlin packages are generated from it through UniFFI, and the Node and Python packages wrap it through native addons. Integrate at whatever layer fits: raw REST for a game engine or middleware runtime, or the typed native SDK for your platform.

🌐REST + SSE

POST /v1/jobsany HTTP client — no SDK requiredSubmit a job, poll it, or subscribe to its server-sent-event stream. The lowest common denominator every binding sits on top of.

🦀Rust

arclode-sdkcargo add arclode-sdkThe hand-written async core. One pooled, keep-alive HTTP/2 client; incremental SSE + WebSocket decoding. Every other binding wraps this crate.

🕊️Swift

ArclodeSDK · SwiftPMimport ArclodeSDKGenerated from the Rust core via UniFFI. Native async/await; SSE + WebSocket streams delivered through an EventObserver.

🤖Kotlin

com.blackleafdigital.arclode · Mavenimplementation("com.blackleafdigital.arclode:sdk")Same UniFFI core as Swift. Every network call is a coroutine suspend fn; streams arrive on an EventObserver.

📦Node / TypeScript

@arclode/sdk · npmnpm i @arclode/sdkA native (napi-rs) addon over the Rust core — a typed index.d.ts, Promises, and (err, frame) stream callbacks.

🐍Python

arclode-sdk · PyPIpip install arclode-sdkA pyo3/maturin abi3 wheel over the same core. Every call is async def; streams are async iterables (async for frame in …).

QuickstartAuthenticate with an Arclode key (Authorization: Bearer, or the equivalent X-Arclode-Key header), submit an image-generation job, and poll it to a finished result. The same three calls, five ways — pick your language.

Stream instead of pollEvery run also exposes a server-sent-event stream —GET /v1/jobs/{run_id}/events — decoded frame by frame as it arrives. In the SDKs that isjobEvents (Node (err, event)callback), job_events (Pythonasync for), andjobEvents(runId:observer:) (Swift / Kotlin EventObserver, returning a cancelable stream handle).CapabilitiesEvery capability is a kind you pass toPOST /v1/jobs. The catalogue is discoverable at runtime —GET /v1/capabilities is the live source of truth, and reports a worker count per kind (its entries are built only from workers actually connected right now). We label below what the network routes today versus what is still coming online, so you never have to guess.

Routing todayLive

Image generationText-to-image / 2D art generation through a single endpoint.

inference:image:generate

Image → 3D meshTurn a single image into a textured 3D mesh.

inference:3d:image-to-mesh

Text → 3D meshGenerate a 3D mesh straight from a prompt.

inference:3d:text-to-mesh

Video generationScene / image → controlled, consistent video.

inference:video:generate

Texture generationPBR textures for an existing mesh or object.

inference:texture:generate

Auto-rigSkeleton + skin weights for a mesh, automatically.

inference:rig

Rolling outRolling out

These kinds are in the contract and the serving code is built, but no worker advertises them yet — so treat them as coming online, not live throughput. Watch GET /v1/capabilitiesfor a non-zero worker count before you depend on one.

Text generationOpen LLMs served on the network — prompt in, generated text out.

inference:llm:text-generate

Music generationText prompt → a generated music track.

inference:audio:music-generate

Sound effectsText prompt → a generated sound effect.

inference:audio:sfx-generate

Text-to-speechSynthesized speech, optionally voice-cloned from a reference clip.

inference:audio:text-to-speech

TranscriptionAudio → transcribed text (speech-to-text).

inference:audio:transcribe

Agents, bots & toolsBeyond single jobs, Arclode runs agentic flows. You can register a tool that calls your own code, wrap a model + your tools into a bot, and embed that bot in your app — all over the same key.1 · Register a tool from your own codePOST /v1/tools/definitions registers a custom HTTP (or webhook) tool. The gateway validates the JSON-Schema, requires an https URL behind its SSRF guard, and enforces name uniqueness — then the tool surfaces to your agents as custom:<id>. The SDKs expose this as register_tool /registerTool.2 · Build a bot & embed itPOST /v1/bots takes a model, a system prompt, and the tool ids it may call. The gateway creates and auto-publishes the backing single-agent flow and returns the bot with an embedToken and achatUrl — embed it in your app, or open the chat URL directly.Heads up: bots run on the LLM/text kind, which is in the Rolling out set above — the OpenAI-compatible chat surface and worker code are built, but LLM serving is still coming online. Register tools and stand up bots now; checkGET /v1/capabilities for a live worker before you point production traffic at one.Why a networkArclode is the AI-media compute network that pays the machines that run it. Instead of one operator's datacenter, jobs route across a hybrid fleet — a baseline fleet Arclode runs, plus contributor machines (Mac, AMD, Nvidia) that earn for the work routed to them. One identity, one credit balance, powered by Zatabase. That's the thesis:compute for the people, not billionaire datacenters — and for you, it means capacity that scales with the fleet rather than a single vendor's rack.Splitting a job rank by rank is also what makes frontier-scale models reachable: Arclode can stream the layers of a ~1.4-trillion-parameter model through a single H100, one stage at a time — so you can run models that would otherwise demand a frontier-scale cluster, on ordinary hardware.Because the fleet is heterogeneous, every job carries a confidentiality choice, so you place work where its data handling requires:

OpenAnonymous contributor machines on any hardware, best-effort. The cheapest lane — and it makes no confidentiality claim: the operator running a job can see its input and output.TrustedThe job splits across vetted operators (Arclode's own machines, bare metal running our image, operators under contract), with the input and output ranks reserved for them. The bar isvetting and contract, not hardware — a vetted operator on a consumer card qualifies.PrivateA confidential-computing GPU inside an attested CVM: encrypted CPU memory, encrypted VRAM, and the GPU signs an attestation of what ran — so the host cannot read the job and youverify the result rather than trust it.

Live fleet capacity is public — no credential needed — atGET /v1/network/capacity.Integrate in an afternoonMint a key, pull the SDK for your platform, and submit your first job. The full REST reference is in the docs.Get an API keyAPI reference