Skip to content

Supported surfaces

Status vocabulary used on this site:

Status Meaning
SUPPORTED Covered by tests using official SDK objects and synthetic provider transports, with real local KazenAI services where shared admission is involved
EXPERIMENTAL Code may exist; not verified; do not rely on it
UNSUPPORTED Rejected or untested; fail before relying on it

Every SUPPORTED row is verified with synthetic provider transports and local KazenAI services. OpenAI Chat Completions and Anthropic Messages through monitor() (sync and async, non-streaming and streaming) are also verified against the live OpenAI and Anthropic APIs on 2026-10-12 (gpt-6-luna, claude-sonnet-5-5): real responses, recorded cost equal to published pricing for the reported input/output tokens, and denial before dispatch. The LiteLLM, LangChain and LangGraph rows below were also verified live on 2026-10-12 against the paid APIs and a real Agent FinOps service. Other rows carry no claim about a paid provider account.

Provider-SDK install ranges: openai>=1.40,<3 and anthropic>=0.39,<1. Tested versions are OpenAI 1.109.1 and 2.48.0 (Chat Completions), OpenAI 2.54.0 (Responses and the live runs) and Anthropic 0.125.0; other versions inside the ranges are compatible candidates, not independently verified.

A model with a long-context price band (GPT-5.4 and later, GPT-6, Claude Haiku 5.5) is priced from the provider’s exact input count: before the call, the SDK makes one free count request (responses.input_tokens.count, which needs openai 2.x, or Anthropic messages.count_tokens).

Provider surface Status
OpenAI chat.completions.create, sync and async, non-streaming SUPPORTED
OpenAI chat.completions.create(..., stream=True), sync and async SUPPORTED
OpenAI chat.completions.stream(...) context manager SUPPORTED
Anthropic messages.create, sync and async, non-streaming SUPPORTED
Anthropic messages.create(..., stream=True), sync and async SUPPORTED
Anthropic messages.stream(...) context manager SUPPORTED
OpenAI responses.create / responses.parse, sync and async, non-streaming and streaming SUPPORTED (live-verified 2026-10-20 on GPT-6 Luna)
OpenAI responses.stream(...) context manager SUPPORTED (live-verified 2026-10-20 on GPT-6 Luna)
OpenAI chat.completions on a model with a long-context price band (GPT-5.4 and later, GPT-6) SUPPORTED when the request’s size in bytes shows it stays below the long-context threshold (272,000 tokens); requests with images or audio, or that could reach it, are rejected before dispatch (long_context_chat_unsupported)
OpenAI Responses background=True, previous_response_id / conversation / stored prompt, built-in tools UNSUPPORTED — rejected before dispatch
OpenAI Realtime / WebSocket, legacy Completions, Responses compact / connect UNSUPPORTED — rejected on a monitored client
OpenAI embeddings, images, audio, batches, fine-tuning; any method saved before monitor() UNSUPPORTED — rejected before dispatch on a monitored client; allow_unmetered=(...) sends named endpoints without a budget check
Bedrock / Vertex Anthropic wrappers UNSUPPORTED
Integration Status Boundary
LiteLLM 1.106.6 and 1.104.2 SUPPORTED (live-verified) Application-owned and gateway-owned reserve/settle, streaming included: one reservation per call, deny before dispatch, per-customer limits. Gateway-owned: load kazenai.integrations.litellm_gateway.proxy_handler_instance as the proxy’s callback, kazenai 1.2.2 or later; earlier versions did not settle streams or send the customer. A stream the provider cut off or reported no usage for stays pending. Application-owned: models that aren’t OpenAI’s need drop_params: true on the proxy. No universal router or provider claim
LangChain 1.4.4 SUPPORTED (live-verified) ChatOpenAI bound with bind_monitored_chat_openai, ChatAnthropic with bind_monitored_chat_anthropic (invoke/stream/ainvoke/astream). ChatAnthropic betas are not supported under Control
LangGraph 1.2.14 SUPPORTED (live-verified) Requires an explicit declared boundary listing every provider client the nodes use (declare_langgraph_control_boundary(graph, *clients)); raw clients inside arbitrary nodes are not intercepted. Checkpoint interrupt/resume verified
CrewAI 1.15.26 SUPPORTED (live-verified) Native OpenAI and Anthropic LLMs bound with bind_crew_llm_client; kickoff, akickoff, kickoff_async; every LLM the crew can call must be bound. Refused under Control: memory, knowledge, embedders, Crew(stream=True), llm_overlay, non-native LLM classes. Anthropic structured output is not supported
AutoGen UNSUPPORTED

A workflow whose steps use different models or providers gets one budget only through the shared Agent FinOps authority: give every monitored client the same workflow_id (and a feature_id per step for attribution) and set a workflow limit. Each step reserves before dispatch and settles to its own model’s price; when the remaining budget can’t cover the next step’s estimate, that step is denied before the provider call. Verified live on 2026-10-12 with three models across OpenAI and Anthropic. Without FinOps, pass one SharedBudget to every client for a single cap within one process (also live-verified); otherwise each monitor() client enforces its own max_budget_usd independently.

KazenAI emits OpenTelemetry spans with GenAI attributes (model, input/output tokens, service and environment). Route them through a standard OpenTelemetry Collector to Agent FinOps run receipts and to the observability tool you already run.

Destination Status Boundary
Agent FinOps run receipts (POST /v1/traces, OTLP/HTTP JSON) SUPPORTED Collector otlphttp exporter with encoding: json; protobuf is rejected
Datadog APM SUPPORTED (live-verified) OpenTelemetry Collector contrib 0.128.0 with the Datadog exporter. Verified 2026-10-12: spans appear in APM Traces with the correct service, environment and model resource, and carry no keys, auth headers or prompt text. Set DD_SITE for your Datadog region; keep DD_API_KEY on the Collector, never in your application
Datadog LLM Observability view Not claimed Spans reach APM; rendering in Datadog’s LLM Observability product is not verified

Traces are for visibility only. Budget decisions and spend records come from KazenAI’s reserve/settle path, which keeps working with tracing disabled or the Collector unreachable. Prompts and completions are not exported by default.

Streaming marks its shared reservation in-flight before provider dispatch and settles at stream end when provider usage is authoritative. Early cancellation, provider failure, or missing usage moves the shared reservation to pending reconciliation — never silently exact zero and never released as an unstarted call. Optional stream_cutoff_usd may stop upstream generation locally; it does not observe hidden reasoning and does not guarantee the provider stopped generating or billing immediately.

Settlement requests are journaled before delivery. Run the recovery command on a schedule so journaled settlements reach Agent FinOps after a crash or outage:

Terminal window
python -m kazenai.spine.settle_queue flush

Zero overspend, exactly-once execution, universal provider support, guaranteed savings, and production GA are not claimed. Limits cover model calls on the surfaces above, not your own tools, paid APIs or compute.