Panel Inference Fabric
The Fabric page is part of the shared native Panel shell. Read-only visitors can inspect descriptions and permitted state but cannot submit privileged planner or worker-control requests. Administrators see only actions allowed by their role and the exact endpoint scope of their credential; every submitted action invokes the existing Fabric route owner rather than a duplicate simulator. A guided step, including its undo, must pass the same route-specific authorization check.
The Inference Fabric page at
/rust/fabric (also /rust/advanced/fabric) lets
operators inspect registered workers, see heartbeats and recent request
telemetry, plan capacity and placement, inspect timing traces, or—in an
administrator session—change worker registry state and send requests. It
uses the existing fabric endpoints rather than a separate simulation.
Numerical outputs are plans and estimates, not measurements or proof of
available hardware.
Quick start
- Open Inference Fabric and read Registered workers, heartbeats, cache and telemetry. The state view shows registration expiry, load snapshots, cache hints and recent telemetry.
- Open Fabric capabilities to see which operations are exposed.
- Choose a planner such as Route a request, Admit or queue, Scale replicas, or Place replicas on devices. Edit Request (JSON) using your own snapshots, then select Run planner. The example values are illustrative; do not treat them as measured performance.
- Inspect Result and Request sent to verify the exact input and any returned warnings. Invalid JSON is reported without a route call.
- Only administrators can use the Confirm and run buttons for changes. Check the confirmation box first. Register a live worker adds metadata; it does not install or start a runtime. Heartbeat a worker refreshes that metadata, and Remove a worker stops the worker being considered for new routing.
- Dispatch a request and Live streaming test send real requests and can consume compute resources. Use them only when a suitable endpoint is available. A failed request is shown as an error rather than a successful inference.
Guided operations
Open /rust/fabric/guides in an administrator
session.
Register two workers and plan a deployment
- Enter First worker ID, First worker endpoint, Second worker ID, Second worker endpoint and Loaded model label. The two IDs must be new and different. Endpoints must meet the registry's local/fleet address restrictions and include a port.
- Check I have checked the actual worker state and authorize these changes. Then choose Run guided task.
- The guide uses Register a live worker twice and checks each saved ID, then reads Registered workers, heartbeats, cache and telemetry.
- It invokes Place replicas on devices with two
representative device slots. Successful placement is checked using
unscheduled_replicas = 0. The plan does not allocate hardware or start processes; replace the example memory numbers with measured inventory when making an actual deployment decision. - If a step fails, the guide attempts to remove only the worker registrations created by this run. Any rollback failure appears explicitly in the result. On success, ensure the actual workers continue to send heartbeats; registrations expire without them.
Find a prefill bottleneck and apply a routing hint
- Make sure the worker is already registered and ready, and verify its real cached prefixes independently. This task requires a worker with no existing fabric cache hints so that rollback cannot erase an earlier hint.
- Enter Registered worker ID, Loaded model label, Measured request telemetry JSON, Verified cache prefix hashes (JSON array) and Verified resident token count.
- Confirm and select Run guided task. Bottleneck of one request attributes time to queue, prefill, decode or transfer. This guide only proceeds if prefill is the largest contributor.
- Record cached prefixes applies an advisory routing hint; it cannot create a cache in the runtime. Route a request then recalculates the destination using that hint, and the guide verifies the metadata in the state endpoint.
- If a later check fails, the new cache hint is removed. Observe new requests under similar load before treating the hint as an improvement. Decode, queue and transfer bottlenecks need different corrective actions; use the individual planners to investigate them.
Administrators should not run guided actions against a worker that they did not authorize. Viewers can read the fabric state and use planning forms, but state-changing forms and these guided tasks are hidden or refused.
Forms and controls
Every operation has its own form under Inference Fabric with editable JSON input, a one-sentence explanation, results and a request echo. State-changing forms additionally display a confirmation checkbox.
| Control | Tooltip | API route |
|---|---|---|
| Route a request | Choose a worker using queue time, cache reuse and response-time goals. | POST /api/inference/fabric/schedule |
| Admit or queue | Check whether a request can run, wait, or must be refused under budgets. | POST /api/inference/fabric/admit |
| Scale replicas | Estimate worker counts from measured demand and queue pressure. | POST /api/inference/fabric/autoscale |
| Choose a capacity variant | Compare size, speed and quality limits before selecting a variant. | POST /api/inference/fabric/capacity-variants |
| Pair prefill and decode | Rank worker pairs by the cost of moving cached attention data. | POST /api/inference/fabric/pd-rank |
| Where to keep a cache | Compare memory and storage locations with recomputation cost. | POST /api/inference/fabric/offload |
| Place replicas on devices | Plan replica locations using device memory and free-space reserves. | POST /api/inference/fabric/deployment-plan |
| Model transformations to try | List model-size and speed changes that satisfy quality limits. | POST /api/inference/fabric/transform-candidates |
| Rank measured transformations | Rank observed model changes and show trade-offs. | POST /api/inference/fabric/transform-rank |
| Activation-aware precision | Allocate precision based on measured tensor sensitivity. | POST /api/inference/fabric/activation-aware-plan |
| Distillation plan | Describe the stages and checks for training a smaller student. | POST /api/inference/fabric/distillation-stages |
| Aggregate telemetry | Summarize request response times, cache hits and errors. | POST /api/inference/fabric/telemetry-aggregate |
| Bottleneck of one request | Break down a request into queue, prompt, transfer and generation time. | POST /api/inference/fabric/bottleneck |
| Trace one request | Show the stages of a request as a timed trace. | POST /api/inference/fabric/trace |
| Sparsify a weights file | Write a new sparse weights file; an existing output is never replaced. | POST /api/inference/fabric/sparsify |
| Register a live worker | Add a worker claim to the registry; it expires without heartbeats. | POST /api/inference/fabric/workers/register |
| Heartbeat a worker | Refresh a registered worker snapshot and its expiry timer. | POST /api/inference/fabric/workers/heartbeat |
| Remove a worker | Remove a worker from routing; existing cache hints may remain. | POST /api/inference/fabric/workers/remove |
| Record cached prefixes | Advertise cached prompt prefixes as advisory routing hints. | POST /api/inference/fabric/cache/upsert |
| Forget a worker cache | Delete routing hints for all cached prefixes on one worker. | POST /api/inference/fabric/cache/remove-worker |
| Dispatch a request | Send a real request to a selected registered worker; this may consume resources. | POST /api/inference/fabric/dispatch |
| Registered workers, heartbeats, cache and telemetry | See the worker registry, heartbeat expiry, cached-prefix hints and recent request traces. | GET /api/inference/fabric/state |
| Fabric capabilities | Inspect which planning and serving capabilities this installation reports. | GET /api/inference/fabric/capabilities |
| Live streaming test | Send a real streaming request and report its output and timing; administrator only. | POST /api/inference/fabric/stream |
| Register workers and plan | Register two workers, inspect their state and plan replica placement with undo on failure. | Worker registration, state, deployment planning |
| Resolve a prefill bottleneck | Check prompt processing time and advertise a verified cached prefix for routing. | Bottleneck, cache upsert, scheduling |
The Request (JSON) editor accepts up to 256 KiB. Run planner executes read-only computations. Confirm and run is administrator-only for worker registration, heartbeat, removal, cache changes, dispatch and sparsification. Live streaming test requires separate consent and a running endpoint. Sparsify a weights file writes a new file and refuses to overwrite the source or an existing destination.
Editor fields, buttons and guided task tooltips
Every editable field and run or confirmation control displays a
? help marker beside its label. The following entries are
also registered, with the exact tooltip displayed by the native
page.
| Control | Tooltip |
|---|---|
Request (JSON): Route a request
(fabric.schedule-request) |
Edit and validate the JSON request for route a request before it is sent. |
Run: Route a request (fabric.schedule-run) |
Execute route a request through the registered fabric endpoint and inspect the result. |
Request (JSON): Admit or queue
(fabric.admit-request) |
Edit and validate the JSON request for admit or queue before it is sent. |
Run: Admit or queue (fabric.admit-run) |
Execute admit or queue through the registered fabric endpoint and inspect the result. |
Request (JSON): Scale replicas
(fabric.autoscale-request) |
Edit and validate the JSON request for scale replicas before it is sent. |
Run: Scale replicas (fabric.autoscale-run) |
Execute scale replicas through the registered fabric endpoint and inspect the result. |
Request (JSON): Choose a capacity variant
(fabric.capacity-variants-request) |
Edit and validate the JSON request for choose a capacity variant before it is sent. |
Run: Choose a capacity variant
(fabric.capacity-variants-run) |
Execute choose a capacity variant through the registered fabric endpoint and inspect the result. |
Request (JSON): Pair prefill and decode
(fabric.pd-rank-request) |
Edit and validate the JSON request for pair prefill and decode before it is sent. |
Run: Pair prefill and decode (fabric.pd-rank-run) |
Execute pair prefill and decode through the registered fabric endpoint and inspect the result. |
Request (JSON): Where to keep a cache
(fabric.offload-request) |
Edit and validate the JSON request for where to keep a cache before it is sent. |
Run: Where to keep a cache (fabric.offload-run) |
Execute where to keep a cache through the registered fabric endpoint and inspect the result. |
Request (JSON): Place replicas on devices
(fabric.deployment-plan-request) |
Edit and validate the JSON request for place replicas on devices before it is sent. |
Run: Place replicas on devices
(fabric.deployment-plan-run) |
Execute place replicas on devices through the registered fabric endpoint and inspect the result. |
Request (JSON): Model transformations to try
(fabric.transform-candidates-request) |
Edit and validate the JSON request for model transformations to try before it is sent. |
Run: Model transformations to try
(fabric.transform-candidates-run) |
Execute model transformations to try through the registered fabric endpoint and inspect the result. |
Request (JSON): Rank measured transformations
(fabric.transform-rank-request) |
Edit and validate the JSON request for rank measured transformations before it is sent. |
Run: Rank measured transformations
(fabric.transform-rank-run) |
Execute rank measured transformations through the registered fabric endpoint and inspect the result. |
Request (JSON): Activation-aware precision
(fabric.activation-aware-plan-request) |
Edit and validate the JSON request for activation-aware precision before it is sent. |
Run: Activation-aware precision
(fabric.activation-aware-plan-run) |
Execute activation-aware precision through the registered fabric endpoint and inspect the result. |
Request (JSON): Distillation plan
(fabric.distillation-stages-request) |
Edit and validate the JSON request for distillation plan before it is sent. |
Run: Distillation plan
(fabric.distillation-stages-run) |
Execute distillation plan through the registered fabric endpoint and inspect the result. |
Request (JSON): Aggregate telemetry
(fabric.telemetry-aggregate-request) |
Edit and validate the JSON request for aggregate telemetry before it is sent. |
Run: Aggregate telemetry
(fabric.telemetry-aggregate-run) |
Execute aggregate telemetry through the registered fabric endpoint and inspect the result. |
Request (JSON): Bottleneck of one request
(fabric.bottleneck-request) |
Edit and validate the JSON request for bottleneck of one request before it is sent. |
Run: Bottleneck of one request
(fabric.bottleneck-run) |
Execute bottleneck of one request through the registered fabric endpoint and inspect the result. |
Request (JSON): Trace one request
(fabric.trace-request) |
Edit and validate the JSON request for trace one request before it is sent. |
Run: Trace one request (fabric.trace-run) |
Execute trace one request through the registered fabric endpoint and inspect the result. |
Request (JSON): Sparsify a weights file
(fabric.sparsify-request) |
Edit and validate the JSON request for sparsify a weights file before it is sent. |
Confirm: Sparsify a weights file
(fabric.sparsify-confirm) |
Confirm that sparsify a weights file may change state, contact a worker or write a file. |
Run: Sparsify a weights file (fabric.sparsify-run) |
Execute sparsify a weights file through the registered fabric endpoint and inspect the result. |
Request (JSON): Register a live worker
(fabric.workers-register-request) |
Edit and validate the JSON request for register a live worker before it is sent. |
Confirm: Register a live worker
(fabric.workers-register-confirm) |
Confirm that register a live worker may change state, contact a worker or write a file. |
Run: Register a live worker
(fabric.workers-register-run) |
Execute register a live worker through the registered fabric endpoint and inspect the result. |
Request (JSON): Heartbeat a worker
(fabric.workers-heartbeat-request) |
Edit and validate the JSON request for heartbeat a worker before it is sent. |
Confirm: Heartbeat a worker
(fabric.workers-heartbeat-confirm) |
Confirm that heartbeat a worker may change state, contact a worker or write a file. |
Run: Heartbeat a worker
(fabric.workers-heartbeat-run) |
Execute heartbeat a worker through the registered fabric endpoint and inspect the result. |
Request (JSON): Remove a worker
(fabric.workers-remove-request) |
Edit and validate the JSON request for remove a worker before it is sent. |
Confirm: Remove a worker
(fabric.workers-remove-confirm) |
Confirm that remove a worker may change state, contact a worker or write a file. |
Run: Remove a worker (fabric.workers-remove-run) |
Execute remove a worker through the registered fabric endpoint and inspect the result. |
Request (JSON): Record cached prefixes
(fabric.cache-upsert-request) |
Edit and validate the JSON request for record cached prefixes before it is sent. |
Confirm: Record cached prefixes
(fabric.cache-upsert-confirm) |
Confirm that record cached prefixes may change state, contact a worker or write a file. |
Run: Record cached prefixes
(fabric.cache-upsert-run) |
Execute record cached prefixes through the registered fabric endpoint and inspect the result. |
Request (JSON): Forget a worker cache
(fabric.cache-remove-worker-request) |
Edit and validate the JSON request for forget a worker cache before it is sent. |
Confirm: Forget a worker cache
(fabric.cache-remove-worker-confirm) |
Confirm that forget a worker cache may change state, contact a worker or write a file. |
Run: Forget a worker cache
(fabric.cache-remove-worker-run) |
Execute forget a worker cache through the registered fabric endpoint and inspect the result. |
Request (JSON): Dispatch a request
(fabric.dispatch-request) |
Edit and validate the JSON request for dispatch a request before it is sent. |
Confirm: Dispatch a request
(fabric.dispatch-confirm) |
Confirm that dispatch a request may change state, contact a worker or write a file. |
Run: Dispatch a request (fabric.dispatch-run) |
Execute dispatch a request through the registered fabric endpoint and inspect the result. |
Guided operations (fabric.guides-link) |
Open step-by-step administrator tasks for registration and cache routing. |
Result and request sent (fabric.result) |
Read the returned result and inspect the exact JSON submitted for this operation. |
Streaming model (fabric.stream-model) |
Select the exact loaded model label used by the live streaming request. |
Streaming prompt (fabric.stream-prompt) |
Enter the message to send to the selected streaming model. |
Max output tokens (fabric.stream-max) |
Limit generated tokens for the live streaming request. |
Confirm live request (fabric.stream-confirm) |
Acknowledge that the streaming test sends a real request to a worker. |
Stream test (fabric.stream-run) |
Send the confirmed request and inspect streamed output and timing. |
First worker ID (fabric.register-plan-worker-a) |
Choose a new worker identifier that is not already registered. |
First worker endpoint
(fabric.register-plan-endpoint-a) |
Enter the exact permitted local endpoint with scheme and port; never include a credential. |
Second worker ID (fabric.register-plan-worker-b) |
Choose a different new worker identifier that is not already registered. |
Second worker endpoint
(fabric.register-plan-endpoint-b) |
Enter another permitted local endpoint with scheme and port. |
Loaded model label (fabric.register-plan-model) |
Use the same label reported by both workers; this guide does not load the model. |
Confirm guided changes
(fabric.register-plan-confirm) |
Approve the exact worker and cache metadata actions before running this task. |
Run guided task (fabric.register-plan-run) |
Execute every checked step using the real routes and undo reversible steps if a later check fails. |
Registered worker ID
(fabric.prefill-bottleneck-worker-a) |
The ready worker whose cache has been verified by the operator. |
Loaded model label
(fabric.prefill-bottleneck-model) |
The exact model label from this worker's registered snapshot. |
Measured request telemetry JSON
(fabric.prefill-bottleneck-telemetry) |
Paste actual request timing data; only prefill-dominated requests can apply this workflow. |
Verified cache prefix hashes (JSON array)
(fabric.prefill-bottleneck-prefix-hashes) |
Use hashes verified from runtime cache introspection, not values guessed from a prompt. |
Verified resident token count
(fabric.prefill-bottleneck-resident-tokens) |
Enter how many cached prompt tokens the worker really holds. |
Confirm guided changes
(fabric.prefill-bottleneck-confirm) |
Approve the exact worker and cache metadata actions before running this task. |
Run guided task (fabric.prefill-bottleneck-run) |
Execute every checked step using the real routes and undo reversible steps if a later check fails. |
Interpreting results
- Admission and scheduling: these decide whether and where a request could run; they do not send it. Dispatch a request does send it.
- Capacity and deployment: variants, replica counts and device placement depend on your submitted demand and inventory. Scale replicas makes a recommendation but does not start or stop replicas.
- Cache and offload: cache hints are advisory. Where to keep a cache estimates memory, storage and recomputation trade-offs; it does not move a cache.
- Optimization: Model transformations to try, Rank measured transformations, Activation-aware precision and Distillation plan describe candidate changes or stages. Only Sparsify a weights file writes an artifact.
- Telemetry: Aggregate telemetry, Bottleneck of one request and Trace one request consume supplied request measurements. Distinguish observed timing from simulated request samples.
For broader instance and deployment controls see Panel Instances, Panel Fleet and Panel Fit Lab.