# PROXIES.SX Compute Early-access managed text inference on provider-owned Apple Silicon Macs. Product reference reviewed: 2026-09-16. This is not a paid-rental, benchmark or payout test. Canonical overview: https://www.proxies.sx/compute JSON index: https://www.proxies.sx/compute/index.json Product contract: https://www.proxies.sx/compute/review.json Choose a model and live machine: https://compute.proxies.sx/models Customer login: https://compute.proxies.sx/login Required provider signup: https://farmer.proxies.sx/signup Provider compute dashboard: https://farmer.proxies.sx/compute Provider earnings: https://farmer.proxies.sx/earnings Provider payouts: https://farmer.proxies.sx/payouts Mac-owner agent runbook: https://agents.proxies.sx/compute/skill.md Provider guide: https://agents.proxies.sx/compute/ Provider onboarding: inspect an existing installation and rental state first. Create a farmer account, verify email, complete the current countersigned Partner Agreement and create a scoped compute supply key. Use the installer's hidden interactive prompt. Agent --status and --doctor separate service/runtime state from key access; --configure-key validates a privately entered replacement without reinstalling or automatically restarting. Do not interrupt an occupied Mac. Admission requires a passing benchmark within 24 hours, its measured model ready, and explicit admin approval. Approved matching suppliers retain seven-day maintenance. Pending benchmarks are not approval. Review admin-approved price/share before listing; a listing flag is not live stock. The catalog supports three pinned Qwen3.8 27B configurations. Read live inventory and machine quotes before funding or purchasing. No stock, historical prices or supplier shares are cached here. Current product data: https://api.proxies.sx/v1/peer/compute/catalog, https://api.proxies.sx/v1/peer/compute/tiers, https://api.proxies.sx/v1/peer/compute/marketplace, https://api.proxies.sx/v1/peer/compute/stats Stripe or supported CoinGate checkout funds shared USD balance; a separate explicit purchase allocates a 30-day rental. Renew manually at a current quote; accepted terms remain fixed. Accrual, settlement and completed payouts are separate; supplier terms show settlementMode and payoutNote. Inference accepts X-API-Key or Authorization: Bearer with an owned rental and compute:infer. One job runs per node. The 60 requests/minute throttle is keyed by client IP and endpoint handler; additional per-key/account limits may apply. Output is capped at 4096 tokens. The agent generation deadline is 175 seconds; API wait defaults to 180 seconds. No tools, response_format, vision, arbitrary models, clusters, SSH or confidential computing. Proxy MCP/x402 does not buy Compute. Product reference: https://agents.proxies.sx/compute/facts.json # Rent an Apple Silicon Mac for dedicated inference Canonical: https://www.proxies.sx/compute/rent Audience: Renters Product reviewed: 2026-09-16 A dedicated endpoint makes sense when you have recurring model traffic and want to reserve a machine for it. Start with the model your application needs, then check whether a listed Mac can serve it. ## What happens between finding a Mac and running a prompt? A balance top-up does not reserve compute. A rental exists after the quoted purchase successfully allocates a machine. Renew manually at a new quote for another 30 days. - Paid term: 30 days - Renewal: Manual - Request limits still apply: No token fee 1. Check ready stock: Find a suitable machine and review its effective price before adding funds. 2. Sign in and fund balance: Use Stripe card checkout or the CoinGate options offered at checkout. 3. Confirm the current quote: The portal checks price and pricing version. A pending operation is unresolved. 4. Use the allocated endpoint: A completed purchase supplies the rental. Confirm model readiness, then send text requests. Documented purchase sequence, not a completed checkout test. Failed allocation reverses its charge to account balance. [Current product reference](https://agents.proxies.sx/compute/facts.json), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## What the rental includes PROXIES.SX Compute is an early-access marketplace for managed inference on provider-owned Apple Silicon Macs. Each rental allocates one approved machine exclusively to one customer for 30 days through a chat-completions API. The provider runs the model through MLX. You receive API access; shell access and a remote macOS desktop are outside this product. [Provider documentation](https://agents.proxies.sx/compute/) There is no per-token charge. The accepted price covers a 30-day rental; request limits still apply and the machine has finite throughput. Context length, simultaneous requests and generation length affect how much useful work it can complete. A fixed bill does not establish a latency guarantee. ## Check stock before you plan a migration Start with a supported model in the [customer model selector](https://compute.proxies.sx/models), then inspect compatible machines. The [public marketplace API](https://api.proxies.sx/v1/peer/compute/marketplace) returns current eligible listings. [Fleet statistics](https://api.proxies.sx/v1/peer/compute/stats) describe aggregate fleet state and are not rentable inventory. A failed inventory read leaves availability unknown; an empty successful response means no visible rental stock. A published tier is a pricing category. A model catalog entry is a supported configuration. Neither means a machine is available to rent. Avoid scheduling a production cutover until a suitable listing exists and you can test the assigned endpoint. ## From an available machine to your first request Choose the model in the [customer portal](https://compute.proxies.sx/models) first. When a suitable ready machine exists, sign in, review its price and fund the shared USD account balance through Stripe card checkout or the cryptocurrency choices shown by CoinGate. Review the current machine quote again before confirming the rental. Currency and network choices come from hosted checkout; compute does not use x402. The customer portal submits the expected price and pricing version. A changed quote is rejected before charge. A pending purchase is still unresolved: let the portal reconcile that operation rather than creating another purchase. A successful balance top-up alone does not allocate a Mac. Once allocation completes and the model is ready, use the rental chat endpoint. [Current purchase contract](https://agents.proxies.sx/compute/skill.md) Completed purchases are non-refundable. If checkout cannot allocate the machine, its charge is reversed to account balance. Cancellation preserves access through the paid term. Renew manually for another 30 days at the displayed quote; there is no automatic renewal. Recorded outages pause remaining rental time, while a model download you request uses rental time. [Product reference](https://agents.proxies.sx/compute/facts.json), [rental operation reference](https://agents.proxies.sx/compute/skill.md) ## Choose with your actual workload Take a small evaluation set from the work you intend to send. A document assistant should include long documents and questions whose answers are absent from the source. A coding assistant should include representative repository tasks and a way to check its output. Remove sensitive material from this first test. Record the exact model ID and quantization. Then measure answer quality, time to first token and completion time at your expected concurrency. A machine that performs well for one short prompt may queue under several long requests. Use the [benchmark worksheet](https://www.proxies.sx/compute/benchmarks) to make comparisons repeatable. ## Fit the application to the API The customer documentation shows a rental-specific base URL and a renter API key scoped to read and inference. Our [compute API guide](https://www.proxies.sx/compute/api) explains discovery and the documented request shape. Compatibility with chat completions does not establish support for every feature in a model SDK. The current documentation rejects tools and `response_format` request fields. Check those limits before choosing this endpoint for an agent that depends on native tool calling or constrained output. Run your agent orchestration and tools on infrastructure you control. The rented endpoint supplies model inference. If the agent also needs a carrier exit IP to collect web data, that is a separate [proxy integration](https://www.proxies.sx/for-ai-agents). ## Work through a rental acceptance sheet Before paying, write down the result your application must achieve. Use the following questions to decide whether a dedicated inference rental fits the job. | Your requirement | Evidence to collect | | --- | --- | | A particular language or extraction task | Answers from your saved evaluation set using the assigned model. | | Interactive responses | First-token and full-response timings at your busiest expected concurrency. | | Long documents | The complete prompt and output budget, plus the endpoint's request-size limits. | | Native tool calling | A supported request contract. The current compute docs reject tools fields. | | Predictable spending | The full 30-day price, renewal choice and any fallback service costs. | | Production continuity | Current stock, outage behavior and a tested application recovery path. | Keep the acceptance sheet with the rental ID and model revision. If you change the model, repeat the quality checks before moving all traffic. A result from a different precision or revision should not silently become the approval record for the replacement. The customer documentation says recorded offline time extends the rental term. That extension preserves paid rental time; it does not process a request while the machine is disconnected. Confirm your node's recorded extension in the dashboard, and keep an application deadline for time-sensitive jobs. [Rental operation documentation](https://compute.proxies.sx/docs) ## Decide what happens when a node is unavailable The customer documentation describes a `node_offline` error while a machine is disconnected. Decide whether your application can wait, return a clear failure or use an independently configured fallback. Set a maximum retry period so a background job cannot wait indefinitely. [Customer documentation](https://compute.proxies.sx/docs) Dedicated tenancy identifies who shares the rented capacity. It does not establish that a machine owner cannot observe data processed on their hardware. Use the [inference privacy guide](https://www.proxies.sx/compute/inference-privacy) to review prompt handling, retention and fallback destinations before using confidential inputs. The published retention policy allows temporary relay storage, and suppliers administer their own machines. The public materials do not establish confidential computing or a compute-specific uptime SLA. Review the [pricing calculation](https://www.proxies.sx/compute/pricing), then use the customer dashboard to inspect an available machine and its current terms. --- # Rent out your Mac for AI inference Canonical: https://www.proxies.sx/compute/providers Audience: Providers Product reviewed: 2026-09-16 A farmer account is required to provide compute. Create it first, then connect a Mac you already own and can keep available. Your farmer portal is where you manage nodes, listings, earnings and payout requests. ## An installed agent is one step toward an approved listing. You need a verified farmer account, a countersigned agreement, a ready model, a passing benchmark and admin approval. Review the approved price and share in the Compute dashboard. - Current agent version: 0.3.3 - Minimum installed RAM: 24 GB - Free disk for smallest setup: 26 GB 1. Account and agreement: Create your farmer account, verify email and complete the signed and countersigned agreement. 2. Supply key and runtime: Create the key in Farmer → Compute. Install the native Apple Silicon agent on macOS 14+. 3. Readiness and review: Keep the measured model ready. Admission needs a passing benchmark within 24 hours and explicit admin approval; occupied nodes are protected. 4. Approved terms and listing: Check locked pricing and your share. A proposed price has no effect until admin approves it. Keep the Mac plugged in, awake and online. Starting at login does not prevent lid-close sleep. Listing and free tests do not earn rental income. [Provider documentation](https://agents.proxies.sx/compute/), [Current product reference](https://agents.proxies.sx/compute/facts.json), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## For an AI agent helping a Mac owner Read the [Compute operating guide](https://agents.proxies.sx/compute/skill.md) first. Inspect an existing installation and its rental state before installing, restarting or changing credentials. Use supported diagnostic flags; invoking the agent without a flag starts another foreground process. Never read out, paste or upload API keys, config.json, state.json or unredacted logs. Device identity files contain private credentials too. ## Create the required farmer account [Create a farmer account](https://farmer.proxies.sx/signup), verify its email and complete the [Partner Agreement](https://farmer.proxies.sx/agreement). A submitted signature still needs the platform countersignature. Use the farmer account even if you already have a renter account. Open [Spawn API key](https://farmer.proxies.sx/api-keys?purpose=compute), select **Compute supplier**, enter a recognizable name and press **Create API key**. This creates a key with `account:read` and `compute:supply`. Enter the complete one-time displayed key only at the installer's hidden prompt. A renter inference key, account ID or shortened key label is not a supplier credential. Accounts can have five active keys; if the limit is reached, identify an unused key before revoking anything in [key management](https://farmer.proxies.sx/api-keys). Keep keys used by other working Macs active. ## Check the Mac before downloading The agent requires Apple Silicon, at least 24 GB of memory, macOS 14 or later, native arm64 Node.js 18 or later and native arm64 Python 3.10 or later. Intel and Rosetta processes are unsupported. Use a supported Node.js release that meets the minimum. [Agent source](https://agents.proxies.sx/compute/compute-agent.js), [Node.js releases](https://nodejs.org/en/about/previous-releases) The [Mac compute eligibility checker](https://www.proxies.sx/tools/mac-compute-checker) compares these values for you and lists each requirement that fails. ```sh uname -m sw_vers -productVersion sysctl -n hw.memsize node -p 'process.arch + " " + process.version' python3 -c 'import platform, sys; print(platform.machine(), sys.version.split()[0])' df -h "$HOME" ``` The memory command reports bytes. Node and Python must report arm64. The installer requires at least 26 GB free; the model downloader requires the selected model's approximate weight size plus 10 GB on its cache volume. Custom `HF_HOME` or `HF_HUB_CACHE` can place that cache elsewhere. A 48 GB or 96 GB Mac normally selects a larger model and needs more disk than the minimum. Check the [catalog](https://www.proxies.sx/compute/models). If the installed script exists, inspect it first: ```sh node "$HOME/.proxies-compute/compute-agent.js" --status ``` Check its matching device in the farmer portal, including any active, cancelled-grace or outage-paused rental. Keep a working installation in place. A rented Mac needs coordinated maintenance through farmer support before an interruption. ## Install the agent and its managed runtime Use this branch when there is no working installation to preserve. Download into a separate working directory and read the source before installing: ```sh curl --fail --show-error --location --output compute-agent.js https://agents.proxies.sx/compute/compute-agent.js node compute-agent.js --install ``` The installer prompts without echoing when no key is already selected. It reuses a saved key, while `API_KEY` in the shell overrides the saved value. It validates supplier access before changing the installation. A rejected selected key needs [credential diagnosis](https://www.proxies.sx/compute/provider-troubleshooting), not repeated reinstalls. If there is no interactive terminal for the hidden prompt, return that step to the owner rather than embedding a secret in a tool call. The installer creates the private Python environment `~/.proxies-compute/runtime-0.31.3` with MLX LM 0.31.3, MLX 0.31.2 and Transformers 5.4.0. These are the supported runtime pins; no global pip installation is needed. It saves the key in `~/.proxies-compute/config.json` with mode 600, copies the script into `~/.proxies-compute` and loads the user's `sx.proxies.compute` launchd service. [Installer source](https://agents.proxies.sx/compute/compute-agent.js) Keep the Mac powered, awake and connected. The service starts at user login; launchd does not prevent lid-close sleep. Allow model downloads to progress before intervening. Use the supported read-only checks after installation: ```sh node "$HOME/.proxies-compute/compute-agent.js" --status node "$HOME/.proxies-compute/compute-agent.js" --doctor ``` ## Complete verification and supplier approval Match the status report's device to [Compute in the farmer portal](https://farmer.proxies.sx/compute). The agent downloads an immutable catalog revision and checks local generation before reporting ready. The measured model must still be serving when admin approves the node. | Stage | What to confirm | | --- | --- | | Account | Verified email, current signed/countersigned agreement and a valid supply key. | | Agent | Matching device, supported agent version and recent valid heartbeat. | | Model | The assigned model is ready, with no unresolved download or runtime error. | | Benchmark | A valid passing measurement no more than 24 hours old for admission. Pending is not passed. | | Compute approval | Explicit admin approval of the measured tier; generic verified is insufficient. | | Pricing | Review the admin-set rental price, platform percentage and your remaining share. | | Listing | After approval, enable List for rent and verify the actual listing state. | Read each node's `admission.status`, `benchmarkFresh`, `benchmarkExpiresAt`, `benchmarkPending`, `automaticBenchmark` and `approvalEligible` inside its `admission` object. Missing or failed reads remain unknown. A free ready unapproved node automatically refreshes missing, invalid or expired measurements, with at least an hour between attempts. Eligibility to run is not proof a job is queued. Pending or running benchmarks temporarily exclude checkout. Admitted nodes use a seven-day maintenance interval while free; the 24-hour admission window expiring does not itself remove their approval. A larger served model can require a new benchmark. No automatic benchmark runs on an occupied or admin-blocked node. Admin diagnostics on a free ready node do not clear a block. More RAM alone does not establish a higher admitted tier. [Admission reference](https://agents.proxies.sx/compute/skill.md) `listedForSale: true` is listing intent, not proof of approval or available supply. A machine becomes rentable only when its agreement, admission, listing, readiness and free-capacity checks all pass. If admin review is pending, keep it ready and report that pending step; do not call onboarding complete before listing is verified. ## Manage income and costs in the farmer portal Admin sets rental pricing and platform/farmer percentages. You can submit one pending price proposal per node with a reason. Approval changes the effective quote for future purchases and renewals; a proposal alone changes nothing. Rejection keeps the price and shows the review note. Accepted rentals retain their agreed price and split. [Pricing reference](https://agents.proxies.sx/compute/skill.md) Paid rentals accrue the approved share. A listing or complimentary allocation produces no rental earnings. Accrual, settlement and completed payout are separate states. Read authenticated `settlementMode` and `payoutNote` in the farmer portal; if settlement is in shadow mode, admin settlement and payout review are required. No demand, income or automatic payout is guaranteed. Use [Earnings](https://farmer.proxies.sx/earnings) and [Payouts](https://farmer.proxies.sx/payouts) to reconcile income and requests. The [provider calculator](https://www.proxies.sx/compute/provider-earnings) uses your approved price/share, occupancy assumptions and operating costs. Compute nodes serve inference and are excluded from proxy routing; the [Peer Network](https://www.proxies.sx/peers) is a separate bandwidth product. Before updating or removing an occupied node, arrange maintenance through farmer support. An authorized retirement can use `node "$HOME/.proxies-compute/compute-agent.js" --uninstall`. It removes the service and saved key while preserving identity, runtime and downloaded models. Revoke only the retired key and check other applications before deleting shared model caches. The difference between pausing with `--uninstall` and leaving for good with `--remove` is set out in [renting out your Mac safely](https://www.proxies.sx/compute/renting-out-your-mac-safely). ## Report the outcome to the owner Report observed Mac prerequisites, installed agent/service state, safe doctor result, matching device/model state, agreement and benchmark status, explicit approval, listing, rental state and the next responsible person. Include an observation time. Keep secrets and customer prompts out. A ready listed Mac is prepared for demand; it does not prove a paid rental, customer workload success or completed payout. --- # Apple Silicon memory and performance for LLM inference Canonical: https://www.proxies.sx/compute/apple-silicon Audience: Providers Product reviewed: 2026-09-16 The chip name alone cannot tell you which model a Mac will serve. Start with usable memory, account for the context your workload needs, then measure performance on that configuration. ## Memory requirements are not download sizes. The smallest catalog configuration requires 24 GB of RAM and approximately 16 GB on disk. Model weights, runtime allocations, context state and macOS use different parts of the capacity budget. - Catalog memory requirements: 24 / 48 / 96 GB - Approximate model disk sizes: 16 / 30 / 55 GB - Verified tier and admission: Separate review Switch the chart metric to inspect RAM, disk or context separately. Installed RAM alone does not establish a tier or guarantee rental demand. [Live model catalog](https://api.proxies.sx/v1/peer/compute/catalog), [Provider documentation](https://agents.proxies.sx/compute/) ## What unified memory changes MLX uses Apple Silicon's shared memory architecture. The CPU and GPU can work with arrays in the same memory without copying them between separate CPU and GPU memory pools. This is useful for large model weights, but it does not turn installed RAM into a promise of generation speed. [MLX unified memory documentation](https://ml-explore.github.io/mlx/build/html/usage/unified_memory.html) macOS and other applications also need memory. Model execution adds temporary allocations, and a conversation's stored attention state can grow with context. Read a catalog's memory requirement as a service configuration requirement, not as the size of the model download. ## A first estimate for model weights For a dense model with 27 billion parameters, four bits per parameter gives a raw weight estimate of 13.5 billion bytes, about 12.6 GiB. Eight bits gives 27 billion bytes. Sixteen bits gives 54 billion bytes. These are arithmetic estimates before quantization metadata, non-quantized tensors, working memory and context state. That explains why a 16 GB download and a 24 GB memory requirement can both be correct. It does not prove that every 27B model will run in 24 GB, or that two quantizations will produce equivalent answers. Use the requirements for the exact model repository and the [4-bit versus 8-bit evaluation guide](https://www.proxies.sx/compute/quantization) to test the quality your application needs. ## The supported PROXIES.SX requirements The [live catalog](https://api.proxies.sx/v1/peer/compute/catalog) lists Qwen3.8 27B in three configurations: 4-bit at 24 GB required memory and 16,384 maximum context; 8-bit at 48 GB and 32,768 context; bf16 at 96 GB and 32,768 context. These are API fields, not independent benchmark results. The [model guide](https://www.proxies.sx/compute/models) includes the exact IDs and repositories. The tiers correspond to these three 27B configurations. Each machine needs a valid benchmark, the measured model ready, a current countersigned agreement and explicit Compute approval. Admission uses a 24-hour measurement window; already admitted free nodes use a seven-day maintenance interval. Verify the exact model and an approved listing together; installed memory alone does not determine the admitted tier. ## Mac mini, Mac Studio or MacBook Pro For an existing Mac mini or Mac Studio, check its configured memory rather than assuming that every machine in the product line has the same capacity. A permanently connected desktop avoids a laptop's lid, battery and travel interruptions. Leave room for airflow and measure power under the workload you will actually serve. A MacBook Pro can be useful if it can stay powered and available for the rental. If it is also your daily work machine, account for competing memory and GPU use. The hardware gate is Apple Silicon with at least 24 GB memory and the supported macOS/runtime versions, not a particular Mac product name. Check sustained power, cooling and availability on the actual machine. [Hardware guidance](https://agents.proxies.sx/compute/#hardware) If you are choosing a new Mac mini, the [Mac mini configuration guide](https://www.proxies.sx/compute/mac-mini) maps each memory option on Apple's current spec page to the catalog requirements. ## Read memory pressure while the workload runs On a Mac you operate, open Activity Monitor's Memory tab while serving a representative workload. Apple describes memory pressure as a combination of free memory, swap rate, wired memory and cached files. Record pressure and swap alongside the response timings. One free-memory number before loading the model misses the conditions under load. [Apple memory monitoring](https://support.apple.com/guide/activity-monitor/view-memory-usage-actmntr1004/mac) Repeat the observation with a longer prompt and the simultaneous requests you intend to serve. If pressure rises while responses slow, reduce the workload and inspect the model's configuration before committing that machine to a rental. This is a diagnostic comparison, not a universal threshold for every Mac. Context state is commonly called the KV cache, short for key-value cache. It stores attention information used during generation. Its size depends on the architecture, runtime, sequence lengths and active requests. Quantizing model weights does not automatically apply the same precision to that cache. The [quantization guide](https://www.proxies.sx/compute/quantization) separates those choices. For renters, these host observations may be unavailable through the managed API. Mark them unknown and evaluate the endpoint's behavior directly. Providers can add host measurements to the [benchmark worksheet](https://www.proxies.sx/compute/benchmarks). ## Separate fitting a model from serving a customer Loading a model proves that it fits that runtime configuration. A useful service also needs acceptable response time, answer quality and recovery from interruption. Test long prompts and several simultaneous requests instead of relying on the fastest short completion. Record the machine's configured RAM, runtime version, model revision and power conditions with the result. The [benchmark guide](https://www.proxies.sx/compute/benchmarks) supplies a worksheet. If your aim is rental income, test existing hardware first and put measured operating costs into the [earnings calculation](https://www.proxies.sx/compute/provider-earnings). --- # Compute model catalog and memory requirements Canonical: https://www.proxies.sx/compute/models Audience: Renters Product reviewed: 2026-09-16 The public catalog identifies models and their memory and context requirements. Match a pinned model revision to an approved machine listing before planning a rental. ## Compare the supported catalog by the limit you need. All three entries belong to Qwen3.8 27B. Precision, required memory, disk and context differ. The exact model IDs and immutable revisions appear in the tables below. - In the reviewed catalog: 3 entries - Model family size: 27B - Repository revisions: Pinned Supported catalog configurations. Model support is separate from rentable stock; confirm both before choosing a machine. [Live model catalog](https://api.proxies.sx/v1/peer/compute/catalog) ## Supported model configurations The [catalog API](https://api.proxies.sx/v1/peer/compute/catalog) is the source for supported model IDs, revisions and limits. These configurations match the current product contract. Check its response and compatible stock when choosing a rental; catalog requirements are not measured customer performance. | Model ID | Quantization | Required memory | Approximate disk | Maximum context | | --- | --- | --- | --- | --- | | qwen3.8-27b-4bit | 4-bit | 24 GB | 16 GB | 16,384 | | qwen3.8-27b-8bit | 8-bit | 48 GB | 30 GB | 32,768 | | qwen3.8-27b-bf16 | BF16 (16-bit) | 96 GB | 55 GB | 32,768 | The corresponding model repositories are [Qwen3.8-27B-4bit](https://huggingface.co/mlx-community/Qwen3.8-27B-4bit), [Qwen3.8-27B-8bit](https://huggingface.co/mlx-community/Qwen3.8-27B-8bit) and [Qwen3.8-27B-bf16](https://huggingface.co/mlx-community/Qwen3.8-27B-bf16). A repository identifies the model files; its availability does not establish inference quality or rental stock. ## Use the catalog ID in the rental API The short ID, such as `qwen3.8-27b-4bit`, identifies the platform model. The longer `mlx-community/...` name identifies the repository used by the serving runtime. Keep those fields separate in your integration. Copy the assigned model ID from the customer dashboard and use the [documented rental request](https://www.proxies.sx/compute/api). For a reproducible evaluation, also record the repository revision. A repository name can remain unchanged while its files are updated. The catalog includes a 40-character revision hash for each entry. The agent downloads that revision and serves its local snapshot. Preserve the full hash with evaluation results. It identifies intended model files; the node must also report the exact model ready and pass admission checks. [Pinned download behavior](https://agents.proxies.sx/compute/compute-agent.js) ## Preserve the exact model revision These are the revisions pinned in the current catalog and agent. Preserve the exact revision returned by the live API with your evaluation. A pinned hash establishes file identity, not answer quality or speed. | Catalog model | Pinned revision | | --- | --- | | qwen3.8-27b-4bit | `3e6447f082e89cc7f0bc6e5441afd38dfce760ff` | | qwen3.8-27b-8bit | `815b83c0df8ffd1d1b5244cf75fd6ef14fca9ef9` | | qwen3.8-27b-bf16 | `6f265714824f3c38d4452baa1628aef3d9b9aae9` | Hugging Face supports selecting a repository snapshot by its full commit hash. Saving the hash helps separate a runtime change from a change in the model files. [Download revision documentation](https://huggingface.co/docs/huggingface_hub/guides/download) Read the model card associated with the revision for intended uses, training context and evaluation limits. Hugging Face's model-card format includes these fields, but their presence and completeness vary by repository. A conversion repository can require checking the original model card as well. [Model card documentation](https://huggingface.co/docs/hub/model-cards) Keep tokenizer and prompt-format changes in the evaluation record too. The same weight revision can produce different behavior when the application changes its system instructions or generation settings. ## Quantization is a choice to evaluate Lower-bit weights reduce the space used to store model parameters. Whether the resulting model is good enough depends on the task. The [quantization comparison guide](https://www.proxies.sx/compute/quantization) explains how to evaluate the variants before paying for more memory or accepting a lower-memory configuration. For extraction, check whether the output contains the requested fields and preserves exact numbers. For code, run the generated code against meaningful checks. For an assistant, include questions where an honest uncertainty response is preferable to a plausible answer. Keep the prompts and scoring rules identical between variants. ## Context is also a capacity limit An advertised maximum context is not an instruction to fill every request to that limit. Your prompt, conversation history and requested answer need an appropriate budget. Longer prompts can take more time before the first token and consume more runtime memory. Build an input-length check into your application. When a document is too large, choose a deliberate strategy such as selecting relevant passages, shortening history or rejecting the request with a clear explanation. Do not let accidental truncation decide what the model reads. ## A catalog entry is not a machine listing Read current eligible machines from the [marketplace API](https://api.proxies.sx/v1/peer/compute/marketplace) after selecting a model at [Models](https://compute.proxies.sx/models). The supported catalog contains these three configurations. Arbitrary repositories, private fine-tunes, multi-Mac deployments, customer containers and training are outside the managed service. A larger chip or a model repository outside this table does not add support. Check both endpoints again when you are ready to rent. Providers can use this table to check memory and disk before following the [setup guide](https://www.proxies.sx/compute/providers). Renters should compare the model evaluation with the [30-day cost](https://www.proxies.sx/compute/pricing). --- # Dedicated inference pricing for a 30-day Mac rental Canonical: https://www.proxies.sx/compute/pricing Audience: Renters Product reviewed: 2026-09-16 Consider a dedicated endpoint when its model passes your evaluation and you have recurring work for it. Compare the full 30-day rental price with the token bill for that workload. ## A tier default is a reference, not your machine quote. Admin may approve a different price for an individual Mac. Checkout uses the effective machine price and pricing version. Accepted terms remain fixed for that intent; a new renewal needs a current quote. - Compute purchase funding: USD balance - Term, not a calendar month: 30 days - Approved price overrides: Per node 1. Choose a supported model: Match model requirements to current eligible marketplace machines. 2. Review the machine quote: Admin controls the effective price. The listing can differ from a tier default. 3. Confirm the paid term: Checkout uses the reviewed price and pricing version for a 30-day allocation. 4. Review before renewing: Renew manually using a new current quote; accepted terms are not retroactively rewritten. Current machine prices appear in the live availability panel and rental portal. A tier default is not a reservation. [Live tier defaults](https://api.proxies.sx/v1/peer/compute/tiers), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## Read the effective machine quote Admin controls tier defaults, per-node overrides and the platform/farmer split. The [tiers API](https://api.proxies.sx/v1/peer/compute/tiers) exposes defaults. The effective machine price and pricing version in the [marketplace API](https://api.proxies.sx/v1/peer/compute/marketplace) determine the current node quote. A farmer price proposal has no effect until admin approves it. | Tier | Minimum RAM | Price to use | | --- | --- | --- | | Starter | 24 GB | Current approved quote for the selected node. | | Pro | 48 GB | Current approved quote for the selected node. | | Max | 96 GB | Current approved quote for the selected node. | Choose a supported model at [Models](https://compute.proxies.sx/models), then review its compatible machines and quote. Billing covers 30 days, with no per-token charge; request limits and finite capacity apply. Dividing a quote by 720 hours is comparison arithmetic, not an hourly purchase option. A tier price does not prove a machine is in stock. ## Calculate the alternative token bill Use input and output tokens separately because their prices can differ. Include any cache discounts or extra charges from the provider you are comparing. ```text token bill = (input tokens / 1,000,000 × input price) + (output tokens / 1,000,000 × output price) dedicated cost per million output tokens = rental price / delivered output tokens × 1,000,000 ``` For a purely hypothetical API charging $1 per million input tokens and $3 per million output tokens, 50 million input and 10 million output tokens cost $80. An assumed $300 rental costs more under those assumptions; use the approved machine price for your own comparison. At 200 million input and 50 million output tokens, the hypothetical bill is $350. These are worked examples, not a competing provider's quote or a claim that the Mac can deliver those volumes. The second formula allocates the whole rental bill to output for comparison. It is not a price PROXIES.SX charges per token. Input processing still consumes capacity even when the rental bill stays fixed. ## Check whether the workload fits into 30 days Suppose your own test measures 10 output tokens per second. Producing 10 million output tokens would take about 278 hours of decoding alone. This excludes time spent reading prompts, loading models, waiting for work and recovering from errors. Ten tokens per second is an illustrative input, not a measured PROXIES.SX result. Do this calculation using your own [benchmark](https://www.proxies.sx/compute/benchmarks). A theoretical price saving has little value if work misses its deadline or needs a second provider to handle peaks. Include that fallback bill in the comparison. ## Compare equivalent work Two APIs with the same chat-completions request shape can serve different models. Compare answer quality before cost. A cheaper response that fails your extraction checks or breaks the agent's tool selection is not equivalent output. Also compare what you manage. A bare-metal Mac rental can include operating-system access and require you to install the model service. PROXIES.SX's documented product supplies a managed inference endpoint. The [cloud comparison](https://www.proxies.sx/compute/vs-gpu-cloud) explains how to separate those buying decisions. ## Calculate cost per accepted result Use successful work as the denominator when the model's output must pass a check. For example, an assumed $300 rental that delivers 10,000 usable extractions allocates $0.03 to each accepted extraction. If only 8,000 pass, the figure becomes $0.0375. These are arithmetic scenarios; neither volume has been measured on this service. Include retries and rejected outputs in the work the node must process. Keep the acceptance rule fixed when comparing services. Otherwise, an API can appear cheaper simply because you allowed it to return less accurate work. For a batch job, compare the expected number of attempts with the successful request rate measured in your [benchmark](https://www.proxies.sx/compute/benchmarks). For interactive work, retain a latency target as well. A 30-day period with plenty of spare capacity can still have a peak hour that fails the application. Completed rentals are non-refundable. A checkout that cannot allocate a machine is automatically reversed to account balance. Cancellation preserves access through the paid term. Read the current checkout terms and operation result before treating a payment as a rental. [Published rental terms](https://compute.proxies.sx/docs) ## Confirm the term in the dashboard Renewal is manual. Top up the shared USD balance through Stripe card checkout or the CoinGate currencies and networks offered at checkout, then explicitly purchase another 30 days at the current quote. Check suitable stock before funding a new compute purchase. A balance top-up is not a rental and does not reserve a machine. The portal submits `expectedPriceUsd` and `pricingVersion` with an `Idempotency-Key`. A timeout or `operation_pending` must be reconciled with the identical request and key. A terminal `price_changed` means no charge for that stale quote: review a fresh quote and start a new intent. Accepted purchases and renewals preserve their recorded price and split; later renewals need a new quote. Recorded outages pause remaining rental time, including past the original expiry. A customer-requested model download uses rental time. [Current pricing and renewal contract](https://agents.proxies.sx/compute/skill.md) If you are supplying the Mac, the rental price is customer revenue before the provider share and operating costs. Use the separate [provider calculation](https://www.proxies.sx/compute/provider-earnings). --- # Compute API integration for AI agents Canonical: https://www.proxies.sx/compute/api Audience: Developers Product reviewed: 2026-09-16 An agent can read the public catalog before it has an account. Sending inference requests requires an active rental and its credentials. Keep discovery, purchasing and model execution as separate application steps. ## Frequency, queue capacity and generation time are different limits. The inference endpoint allows 60 requests per minute by client IP and endpoint handler, with additional key/account limits and one active job per node. A long answer can occupy that node while other requests wait. Measure completed work as well as admitted requests. - Maximum output per request: 4,096 tokens - IP / endpoint throttle: 60 / minute - Active on a node: 1 job 1. Validate the request: Use the assigned model, text messages and an output budget. Tools and response_format are unsupported. 2. Wait for the node: Bound your application queue. The request-rate allowance does not promise immediate execution. 3. Generate and stream: The API wait default is 180 seconds; the agent generation deadline is 175 seconds, with a 60-second idle limit. 4. Handle the result: Check completion and errors. Use a deadline and a bounded retry policy for inference. A schematic of documented limits, not a measured latency timeline. Use a read/inference key for model requests and keep purchase permissions separate. [Current product reference](https://agents.proxies.sx/compute/facts.json), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## Discover the product without credentials These public endpoints support credential-free discovery. None of the following reads creates a rental, starts inference or sends a payment. ```sh curl --fail --show-error https://api.proxies.sx/v1/peer/compute/catalog curl --fail --show-error https://api.proxies.sx/v1/peer/compute/tiers curl --fail --show-error https://api.proxies.sx/v1/peer/compute/marketplace curl --fail --show-error https://api.proxies.sx/v1/peer/compute/stats ``` The responses contain `models`, `tiers` and `machines` arrays, with fleet state in the stats response. Treat an empty machine list as no visible rental supply. Do not substitute the tier list for inventory. Validate the response shape and handle network errors before an automated workflow makes a decision. This site's [compute index](https://www.proxies.sx/compute/index.json) supplies page links and product references as JSON. The [plain-text guide](https://www.proxies.sx/compute/llms.txt) contains the same editorial material as these HTML pages. They are convenience formats; the live product API is the authority for stock and catalog changes. ## Use the rental-specific endpoint The [customer documentation](https://compute.proxies.sx/docs) and its published client example use this base URL: ```text https://api.proxies.sx/v1/peer/compute/rentals/ ``` Create a key on the renter API page with `compute:read` and `compute:infer` scopes. Both `X-API-Key: ` and `Authorization: Bearer ` are accepted. The OpenAI SDK's `api_key` or `apiKey` option sends the supported Bearer header. Set the rental-specific base URL, and use the rental ID and assigned model from your [existing deployments](https://compute.proxies.sx/nodes). Example request: ```sh # Set COMPUTE_RENTAL_ID and COMPUTE_API_KEY from your account. # Replace the example model with the model assigned to your rental. curl --fail-with-body --show-error --max-time 190 \ "https://api.proxies.sx/v1/peer/compute/rentals/${COMPUTE_RENTAL_ID}/chat/completions" \ -H "X-API-Key: ${COMPUTE_API_KEY}" \ -H 'Content-Type: application/json' \ --data '{"model":"qwen3.8-27b-4bit","messages":[{"role":"user","content":"Reply with hello."}],"max_tokens":32,"stream":false}' ``` Keep credentials on your application server or in its secret store. A public browser bundle or a pasted conversation is not an appropriate place for an account key. Consult the customer dashboard for key management. ## Test the features your agent needs Start with a short response, then test streaming and your real prompt lengths. The current customer documentation explicitly rejects tools, stop sequences and `response_format` with HTTP 400. An agent requiring those request fields needs a supported alternative or a different application design. Chat completions do not imply an embeddings endpoint. [Documented request contract](https://compute.proxies.sx/docs) Run the orchestration loop and external tools on your own system. The rented model endpoint returns model output. For document applications, the [RAG hosting guide](https://www.proxies.sx/compute/rag-inference) maps retrieval, source checks and generation to their respective components. A host's larger memory does not automatically make its model reliable at choosing tools or following a schema. ## Bound retries and queue growth Handle `node_offline`, `model_not_ready`, `node_not_approved`, `rental_expired` and `queue_full` according to the reported state. Management operations can also return `node_busy`, `node_rented` or `benchmark_in_flight`; do not work around those allocation guards. Use bounded backoff, an application deadline and a queue limit. A 429 requires backoff; a 504 or incomplete/error SSE stream is a failed request, even if some text arrived. Keep prompt text and credentials out of routine error logs. ## Enforce the published request limits The managed endpoint supports text chat completions within these limits. It does not expose all options from a generic model SDK. | Field or condition | Documented behavior | | --- | --- | | `messages` | 1–64 text messages with system, user or assistant roles; each content string is limited to 65,536 characters by validation. | | `max_tokens` | 1–4096; default 1024. | | Other supported fields | `model`, `temperature` from 0–2, `stream`. | | Streaming | Server-sent events. | | Request deadline | API default 180 seconds; agent generation deadline 175 seconds and idle-output limit 60 seconds. | | Endpoint throttle | 60 requests per minute by client IP and handler; additional per-key/account limits may apply. | | Unsupported generation options | Tools, stop sequences, `response_format` and other unsupported options return HTTP 400. | | Expired, offline or unready rental | HTTP 409 with a specific error code. | A conservative input-byte check also requires the total UTF-8 content bytes, plus 64 per message, plus 256 for formatting, plus the requested output-token cap, to fit the catalog context limit. The per-message and message-count limits are not permission to send their product as one prompt. Bytes and tokens differ: a prompt within a tokenizer-based budget can still fail this stricter input check. Shorten the text or output cap and handle that rejection explicitly. [Customer request documentation](https://compute.proxies.sx/docs) One job runs at a time on each node. Bound concurrent work in your application and expect queueing or rejection at capacity. The throttle is not independent capacity per key or rental, and does not imply that sixty long requests finish every minute. Streaming uses server-sent events; images/audio, embeddings, native tool calling and the Responses API are unsupported. Use the [benchmark method](https://www.proxies.sx/compute/benchmarks) to establish useful throughput. ## Keep purchase permissions separate from inference An inference key needs `compute:read` and `compute:infer` according to the customer docs. Programmatic checkout and renewal additionally require `compute:purchase` and an `Idempotency-Key` header containing 8–128 letters, digits, dashes or underscores. Reuse the same operation key and request after a timeout or `operation_pending`; a new purchase intent gets a new operation key. [Customer checkout documentation](https://compute.proxies.sx/docs) Model changes and cancellation require `compute:manage`. Keys created on the renter API page only grant read and inference; they cannot spend or manage rentals. Supplier keys use `account:read` and `compute:supply` with a farmer account, while the installed agent manages a separate device JWT. Never give a renter a supplier or admin key. Keep spending credentials outside the model prompt and enforce authorization in application code. ## Handle a changed quote differently from a pending purchase Send `expectedPriceUsd` and `pricingVersion` from the current machine quote, as the customer portal does, so a changed price is rejected before charge. Existing rentals expose their current `renewalQuote` through `GET /v1/peer/compute/rentals/mine`. Renewal is an explicit purchase for another 30 days. This website hands checkout to the customer portal. [Purchase and renewal contract](https://agents.proxies.sx/compute/skill.md) | State | What an integration should do | | --- | --- | | Request timed out or `operation_pending` | Retry the existing intent with its original body and idempotency key. | | Terminal `409 price_changed` | No charge occurs for the stale quote. Refresh the quote, obtain confirmation and create a new intent key. | | Allocation fails | Check the operation result and balance reversal; a funded balance alone does not mean a rental exists. | | Rental committed | Use the returned rental and assigned model. The accepted price and split stay fixed for that intent. | Never replace the body of an unresolved intent with a newer quote. Resolve it first. Treat a confirmed rental operation as the purchase result; a CTA click or top-up redirect is not proof of a purchase. ## Proxy payments are a separate integration The existing [x402 guide](https://www.proxies.sx/x402) documents purchasing proxy resources. It does not establish an x402 compute checkout or compute tools in the [proxy MCP server](https://www.proxies.sx/mcp). Use the compute customer flow for rentals and review its current terms. The [agent proxy guide](https://www.proxies.sx/for-ai-agents) remains relevant when an agent needs network access as well as model inference. --- # Mac compute provider earnings after operating costs Canonical: https://www.proxies.sx/compute/provider-earnings Audience: Providers Product reviewed: 2026-09-16 The useful number is the amount left after costs and unrented time. Use the calculator with a machine you own, a measured power figure and an occupancy assumption you are prepared to question. ## Earned share, settled balance and paid cash are different amounts. For each successful paid term, accrual follows its accepted price and approved provider share. Free test allocations earn nothing. Use the rental ledger to check earned amounts and the payout record to check received funds. - Effective share and rental price: Admin-controlled - Basis for actual accrual: Paid terms - Occupancy assumptions: No guarantee 1. Paid rental accrues your share: Use the accepted price × paid terms × agreed share. Sum terms separately if their pricing differs. 2. Review and settle earnings: Read settlementMode and payoutNote in the authenticated farmer terms. Accrual is not a completed payout. 3. Track the completed payout: A payout request is not paid cash. Check its final state in the farmer portal. Existing peer ledger entries are already net of the platform share. Do not subtract that percentage a second time. [Current product reference](https://agents.proxies.sx/compute/facts.json), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## Start with your approved share Use the approved rental price and farmer percentage shown for your node in [Compute](https://farmer.proxies.sx/compute). Admin controls defaults and per-node terms. A farmer proposal does not change either until approved. Enter the actual displayed terms into the calculator; its scenario inputs are not a quote or guaranteed offer. Accepted rentals retain the price and split recorded when purchased. [Current pricing reference](https://agents.proxies.sx/compute/skill.md) Public [fleet statistics](https://api.proxies.sx/v1/peer/compute/stats) and [machine listings](https://api.proxies.sx/v1/peer/compute/marketplace) do not establish historical paid occupancy or completed payouts. Use your own rental and earnings records to check assumptions. Do not treat a listed Mac as continuously rented or buy additional hardware based on an unmeasured demand forecast. ## What the calculator means by occupancy Occupancy represents the share of time rented across several 30-day periods. For example, 50% could mean one full period rented and one period without a renter. It is not a statement that customers can buy half a month, or that the platform prorates a rental by the day. At zero occupancy, rental revenue is zero. A powered machine can still consume electricity. Enter an average wall-power measurement that includes the conditions you expect, such as loaded and idle hours. If you power down between rentals, adjust the average accordingly. ```text actual rental accrual = accepted price × paid terms × approved share fraction estimated share per 30 days = assumed price × approved share fraction × occupancy fraction electricity = average watts / 1,000 × 720 hours × price per kWh estimated operating result = estimated share − electricity − other costs ``` The 720 hours represent exactly 30 days. The result is before taxes and before any costs you have not entered. Occupancy prorating is a planning estimate, not billing or ledger logic. If accepted terms differ between rentals, calculate each term separately and sum its accrual. Confirm your approved terms in the dashboard. ## Include costs that are easy to miss If you already own the Mac, distinguish cash spending from the value of keeping it available for other work. A machine you need during the day may be a poor fit for a dedicated rental, even if its electricity bill is low. If you are considering buying hardware, include depreciation or financing and the risk that demand does not arrive. Also consider incremental connectivity, maintenance and time spent handling interruptions. Put a 30-day allowance for those costs in the calculator instead of treating the electricity figure as the entire expense. ## Use scenarios before expanding The calculator shows zero, 25%, 50% and full occupancy so the dependence on demand remains visible. These scenarios are assumptions, not a probability forecast. A break-even occupancy above 100% means the entered price and costs cannot break even under this model. Measure one existing machine first. Record when it is listed, when it is rented, actual power use, credits received and any downtime. Several completed rental periods are more useful for expansion decisions than a single successful install. ## Measure loaded and idle electricity separately If the Mac stays online between requests, measure both serving and idle power at the wall. Multiply each measurement by the hours spent in that state. A power-adapter rating is not the machine's average consumption. For a hypothetical 30-day period with 240 hours at 70 watts and 480 hours at 20 watts, energy use is 26.4 kWh. At an assumed $0.20 per kWh, that is $5.28. The equivalent average is about 36.7 watts for the calculator. These inputs are examples, not measurements of a Mac model or an electricity tariff. This gives a more useful input than assuming the machine draws full-load power for every hour. Add network equipment only when its cost belongs to this activity, and explain the allocation you use. ## Reconcile earned revenue with available payout balance A farmer account is required to supply the machine. Use its [Compute dashboard](https://farmer.proxies.sx/compute) for listing state, [Earnings](https://farmer.proxies.sx/earnings) for income and [Payouts](https://farmer.proxies.sx/payouts) for payout requests. An estimated share is not cleared cash in your bank or wallet. Successful paid rentals accrue the agreed share; free test allocations earn nothing. Accrual, settlement and completed payout are separate states. Read the current authenticated `settlementMode` and `payoutNote`. In shadow mode, admin settlement and payout review are required; do not interpret an accrual as an automatic payout. Existing peer earnings ledger rows already represent the net farmer share, so do not deduct the platform percentage again. [Settlement reference](https://agents.proxies.sx/compute/skill.md), [earnings reference](https://agents.proxies.sx/compute/skill.md) Keep a record of each rental period, adjustments, amounts credited and completed payouts before estimating future returns. Confirm current payout conditions in the portal. A displayed earnings estimate does not establish payout speed, minimums or fees; read the conditions attached to your payout request. The published revenue-share basis is in the [provider documentation](https://agents.proxies.sx/compute/). ## Keep compute and bandwidth earnings separate Compute rents inference capacity. The [Peer Network](https://www.proxies.sx/peers) pays for routed bandwidth under its own terms. The provider documentation says compute nodes are excluded from proxy routing, so do not add a second bandwidth income assumption to a compute forecast without a separately supported arrangement. When the costs look acceptable, follow the [provider setup guide](https://www.proxies.sx/compute/providers). Confirm the machine can serve a [catalog model](https://www.proxies.sx/compute/models) before listing it. --- # Benchmark Apple Silicon inference on your workload Canonical: https://www.proxies.sx/compute/benchmarks Audience: Developers Product reviewed: 2026-09-16 A tokens-per-second number is incomplete without the model, prompt length and measurement method. Keep those details with the result so another person can repeat the test and understand its limits. ## Measure the selected machine with your own workload. Model support does not establish speed, reliability or task quality. Record the exact machine, pinned model, prompt and output budget before comparing useful completed results. - Time to first token: TTFT - Latency, throughput and quality: Completed work - Include errors and recovery: Repeat trials 1. Fix the workload: Record model ID/revision, context, output budget and acceptance criteria. 2. Measure complete requests: Capture first-token time, completion time and actual returned token counts. 3. Repeat under intended load: Start with one active request; retain errors and rejected or incomplete outputs. 4. Price accepted work: Compare rental cost and observed utilization with the same useful task elsewhere. A measurement workflow, not published fleet benchmark results. Paid-rental and supplier 24-hour proof are not established by this guide. [Current product reference](https://agents.proxies.sx/compute/facts.json), [Provider documentation](https://agents.proxies.sx/compute/) ## Begin with a task and a pass condition Choose the workload before choosing the benchmark prompt. For document extraction, define the fields and compare them with known answers. For code, run an appropriate test or compiler. For an agent that selects tools, check the tool name and arguments against the intended action. Use a saved set of prompts and record how you selected them. Include difficult cases and failures you care about. Keep the same set when comparing models. A fast completion that fails the task should remain visible as a failure. ## Record model identity and environment Save the platform model ID, repository name and revision if available, quantization, runtime version, machine memory and chip. State the date and whether the model was already loaded. If the service does not expose a field, mark it unknown rather than guessing from a tier name. The [PROXIES.SX catalog](https://www.proxies.sx/compute/models) exposes supported models, immutable revisions and configuration requirements. Those fields are not measured customer performance. Record the actual node and model when evaluating a rental. ## Separate admission from workload performance Supplier admission requires a valid passing benchmark no more than 24 hours old, the measured model currently ready, a current countersigned agreement and explicit admin approval. Already admitted free nodes use a seven-day maintenance interval. A pending benchmark is neither a passing result nor approval. [Admission reference](https://agents.proxies.sx/compute/skill.md) The platform benchmark measures delivered output for admission; it is not hardware attestation, a paid-rental result or a long-term availability test. Its passing state does not establish accuracy on your prompts or capacity at your expected concurrency. Use the worksheet below for that evidence. Keep observed measurements distinct from target thresholds and hypothetical examples. ## Separate waiting from generation Measure time to first token from sending the request to receiving the first generated content token. State whether that includes network travel, queueing and prompt processing. A timestamp taken only after response headers arrive misses some of the user's waiting time. For output speed, record output tokens and the generation interval you used as the denominator. A client receiving streamed text chunks should not count chunks as tokens. Use returned token usage when available, or document the tokenizer and counting method. Measure whole-request duration as well so a long prompt cannot disappear from the comparison. ## Repeat under the concurrency you need Test one request first, then run the simultaneous workload the application actually produces. Keep a separate record for each concurrency level. Report the number of attempts, successful responses, timeouts and other errors. For latency, include a median and a high percentile only with enough observations to make it meaningful. A p95 calculated from a handful of requests is unstable. Preserve failed attempts in the dataset rather than quietly removing them to improve the average. A separate 2025 comparative study used a 192 GB M2 Ultra Mac Studio and Qwen-2.5 models to examine five local runtimes. It reported different leaders for sustained generation and first-token latency under its settings. Those results explain why both measurements matter; they do not rank the Qwen3.8 rental configurations here. [Apple Silicon runtime study](https://arxiv.org/abs/2511.05502) ## Use consistent latency and throughput definitions NVIDIA's GenAI-Perf documents distinct measurements for first response, request duration and token throughput. That separation is useful when comparing any inference endpoints; its example results are not Apple Silicon measurements. [GenAI-Perf metric definitions](https://docs.nvidia.com/deeplearning/triton-inference-server/user-guide/docs/perf_analyzer/genai-perf/README.html) | Measurement | Record in your worksheet | | --- | --- | | Time to first token (TTFT) | Request start to first generated content. State if your tool instead uses the first server event. | | Completion latency | Request start to final response. | | Decode rate | Output tokens divided by the declared generation interval. State whether the first token is excluded. | | Aggregate throughput | Completed useful work across all concurrent requests per wall-clock interval. | | Task pass rate | Accepted results divided by all scored attempts. Keep errors visible separately. | If a stream starts with metadata, timing that first event can understate the wait for readable output. Match definitions before comparing numbers from different tools. Use several prompt lengths, with the same output cap and generation settings for each candidate. Run a separate cold-load case, then a warm sequence. Finish with expected peak concurrency and report how many cases you ran. A single fast request cannot establish sustained capacity or a stable high-percentile latency. ## Download the recording worksheet The [CSV worksheet](https://www.proxies.sx/compute/benchmark-template.csv) is an empty recording format. It contains no measured PROXIES.SX performance. Store a prompt-set identifier instead of confidential prompt text when sharing results. Record at least request start, first content token and completion times; input and output token counts; concurrency; status; and the task's quality result. Add power readings if you are evaluating a provider machine. Mark requests made while loading the model separately from requests made after it is ready. ## Turn the result into a capacity decision Estimate whether the successful throughput can finish the expected work inside its deadline. Allow for bursts and interruption. An overnight classification job may tolerate slower responses that would make an interactive assistant frustrating. Then use the [pricing calculation](https://www.proxies.sx/compute/pricing) with measured useful output. For providers, use wall power and observed rental periods in the [earnings calculator](https://www.proxies.sx/compute/provider-earnings). Publish the test conditions with any future speed claim, including the cases that did not pass. Use this method and recording format to produce your own evidence. No model speed, sustained capacity, demand or performance ranking is promised by a catalog entry or an admission badge. --- # Mac inference compared with GPU cloud and bare-metal Macs Canonical: https://www.proxies.sx/compute/vs-gpu-cloud Audience: Renters Product reviewed: 2026-09-16 A managed model endpoint, a remote Mac and a GPU server give you different kinds of access. Decide who needs to install software and what the application must run before you compare the bill. ## Choose access and workload before comparing prices. A managed Mac endpoint supplies catalog text inference. A bare-metal Mac provides operating-system access under its provider terms. A GPU host must match your runtime, memory and software requirements. - PROXIES.SX access: Model API - On a managed rental: No SSH - PROXIES.SX term: 30 days A workload comparison, not a speed or price ranking. Features of a cloud category vary by provider; verify the individual offer. [Current product reference](https://agents.proxies.sx/compute/facts.json), [AWS EC2 Mac access and allocation](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-mac-instances.html), [MacStadium access and pricing](https://macstadium.com/pricing) ## Match the access model to the job PROXIES.SX documents a managed inference endpoint on a dedicated provider Mac. The customer sends model requests through an API. It is suitable to evaluate when a catalog model can do the job and you want the serving process managed for you. [Compute documentation](https://agents.proxies.sx/compute/) For a remote Mac, compare the specific offer's operating-system access, installation permissions, host reservation and storage terms. Use current primary documentation such as [MacStadium](https://macstadium.com/pricing) and [AWS EC2 Mac](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-mac-instances.html). Confirm the selected plan grants the access your workload needs; a managed chat endpoint does not grant a macOS desktop or shell. | Decision | Managed PROXIES.SX inference | Bare-metal Mac | GPU cloud | | --- | --- | --- | --- | | Access needed | Model API | macOS access under provider terms | VM or container access under provider terms | | Software choice | Current catalog and service API | Customer-managed Mac software | Hardware, image and runtime dependent | | Main evaluation | Model quality and endpoint capacity | Mac configuration and administration | GPU memory, runtime and workload fit | | Cost comparison | Full 30-day rental and fallback costs | Rental plus serving and administration | Instance, storage, networking and serving costs | This table is a buying framework. GPU clouds differ, and a category label does not establish an individual provider's features or price. ## When a GPU server is the closer fit If your application requires a CUDA-dependent package, custom container, fine-tuning job or a model outside the managed catalog, establish that requirement first. A chat-compatible API on a Mac does not grant the ability to run arbitrary training code. Confirm the GPU provider supports your image, memory requirement and storage needs before renting. If the only requirement is inference, compare equivalent models with the same prompts and quality checks. A large-memory Mac and a datacenter GPU can have different bottlenecks. Neither the memory number nor the purchase price proves which service will meet your latency target. ## When a remote Mac is the closer fit For Xcode builds, macOS application tests or remote desktop work, you need operating-system capabilities. Compare dedicated Mac services on that basis. Installing your own model server also gives you more control, alongside responsibility for updates, access control and recovery. Compare current approved PROXIES.SX node quotes with a current quote for the alternative configuration, including the reservation period and services you must operate. Equal headline amounts do not establish equivalent access, model capacity or support. A published default is not a stocked machine. [Compute tiers](https://api.proxies.sx/v1/peer/compute/tiers), [eligible compute stock](https://api.proxies.sx/v1/peer/compute/marketplace) ## Compare the reservation period and recovery work Check the selected provider's minimum reservation, billing unit, cancellation terms and recovery obligations directly. A task that runs for minutes can still incur a longer host allocation. Include storage and networking charges where applicable. [EC2 Mac considerations](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-mac-instances.html) PROXIES.SX publishes a 30-day inference rental. Compare the bill over the time you must reserve, then include application hosting, persistent storage and recovery work where they apply. A short benchmark run and a continuously available endpoint can lead to different buying decisions. Write down who restores service after a failure. On a server you administer, that may include rebuilding the runtime, restoring weights and restarting the endpoint. With managed inference, your application still needs to handle failed requests and any fallback destination. See the [rental behavior](https://www.proxies.sx/compute/rent) and [privacy review](https://www.proxies.sx/compute/inference-privacy). For CUDA-dependent work, first establish that the software can run on the candidate GPU host. For Xcode or macOS testing, establish the required Mac operating-system access. Then compare prices for the resulting shortlist. This avoids using a model-only API price as a substitute for a server that your workload actually needs. ## If you want to supply hardware Provider programs need separate comparisons. Check the alternative program's exact host requirements and responsibilities in its primary documentation, such as [Vast.ai hosting](https://docs.vast.ai/host/hosting-overview). PROXIES.SX serves catalog models on Apple Silicon through its agent. Qualifying for one provider program does not establish eligibility for another. Compare the supported hardware, workload access, payment basis, demand and operating obligations. A revenue-share percentage by itself says little about expected income. For PROXIES.SX, begin with the [provider requirements](https://www.proxies.sx/compute/providers) and the [cost scenarios](https://www.proxies.sx/compute/provider-earnings). For a rental decision, put the candidate services through the same [benchmark method](https://www.proxies.sx/compute/benchmarks), then compare the [total bill](https://www.proxies.sx/compute/pricing). --- # Troubleshoot the MLX compute agent on your Mac Canonical: https://www.proxies.sx/compute/provider-troubleshooting Audience: Providers Product reviewed: 2026-09-16 A loaded background service can still have no model ready to serve. Check the agent, Python environment and local model endpoint separately to find where setup stops. ## Find the first failed stage before reinstalling. An online agent, a serving model, a passed benchmark and an approved listing are separate states. Check runtime logs and the farmer dashboard together before changing a working installation. - Documented heartbeat interval: 60 seconds - Missing-heartbeat offline threshold: 3 minutes - Current agent version: 0.3.3 1. Inspect the existing service: Use the installed agent’s --status first. Do not reinstall or start a second agent on a rented Mac. 2. Check the selected key safely: Use --doctor. For an authorized replacement on a free Mac, --configure-key validates before saving; it does not restart the service. 3. Model cannot become ready: Check disk space, download progress, the pinned revision and startup generation errors. 4. Node is paused or offline: Check power, thermal state, sleep and heartbeat. launchd does not keep a closed laptop awake. 5. Ready but not listed: Read admission status and pending benchmark work, then check the countersigned agreement and separate admin approval. A diagnostic path based on the current agent reference, not a report of faults in your node. Redact keys from logs before requesting support. [Provider documentation](https://agents.proxies.sx/compute/), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## Check the installed agent version first For an AI agent, read the [operating guide](https://agents.proxies.sx/compute/skill.md) before changing the Mac. Start with the installed copy when it exists: ```sh node "$HOME/.proxies-compute/compute-agent.js" --status ``` The published agent is 0.3.3. A newly downloaded script's status command reports that script's version; it does not prove the background service was upgraded. Compare the installed path with `agentVersion` in the [farmer Compute dashboard](https://farmer.proxies.sx/compute). Do not run the script without a flag while its service is active: that starts a second foreground agent. [Agent source](https://agents.proxies.sx/compute/compute-agent.js) A loaded launchd service, a listening local port and a model ready in the dashboard are different observations. Check the matching device and any occupying rental before restarting, reinstalling or replacing credentials. Active rentals, cancelled grace and outage-paused terms still reserve the Mac. Coordinate necessary maintenance through farmer support first. ## Diagnose credentials without exposing them Agent 0.3.3 supports a safe supplier-access check: ```sh node "$HOME/.proxies-compute/compute-agent.js" --doctor ``` If the installed copy does not support this flag, download and inspect the current script in a separate working directory, then run `node compute-agent.js --doctor` without installing it. The check reads authenticated supplier pricing and prints the selected credential source, status and result code. It never prints the key. | Result | Next action | | --- | --- | | supplier_access_verified, HTTP 200 | Continue with device, service and model checks. This is not node approval. | | missing_or_invalid_key_format | Use the complete **Compute supplier** key from the farmer API keys page. | | key_not_accepted, HTTP 401 | Check whether the selected key was revoked or replaced. | | farmer_role_or_compute_supply_scope_required, HTTP 403 | Confirm the farmer account and compute:supply scope. Do not substitute an admin key. | | rate_limited_try_later, HTTP 429 | Wait, then retry the same read. | | network_error_try_later or unexpected_response_try_later | Check connectivity and status; repeated key replacement will not repair the network. | An `API_KEY` environment variable overrides the saved configuration. Check the saved key separately without printing either secret: ```sh env -u API_KEY node compute-agent.js --doctor ``` For an authorized credential replacement on a free Mac, create a **Compute supplier** key in [farmer API keys](https://farmer.proxies.sx/api-keys?purpose=compute) and run the current script: ```sh node compute-agent.js --configure-key env -u API_KEY node compute-agent.js --doctor ``` The owner enters the new key at a hidden terminal prompt. `--configure-key` validates before saving, preserves identity/model files and does not restart a running service. A rejected key leaves the prior configuration unchanged. It prints the precise `launchctl kickstart` command for this user's service; execute it only when an interruption is safe and intended. Never delete state.json to force registration or paste config.json, state.json, environment variables or keys into a support chat. ## Diagnose architecture and Python runtime errors The documented minimums are Apple Silicon with 24 GB memory, macOS 14, native arm64 Node.js 18 and native arm64 Python 3.10. These read-only commands identify the executables in use: ```sh node -p 'process.arch + " " + process.version' python3 -c 'import platform, sys; print(platform.machine(), sys.version.split()[0])' sw_vers -productVersion ``` Use a supported Node release that meets the checks. Intel/Rosetta processes fail the architecture requirement. [Node.js release schedule](https://nodejs.org/en/about/previous-releases) The private runtime is `~/.proxies-compute/runtime-0.31.3`. A global terminal reporting `mlx_lm.server: command not found` does not establish that the agent's private environment is broken. Inspect its installed packages directly: ```sh ~/.proxies-compute/runtime-0.31.3/bin/python3 -m pip show mlx-lm mlx transformers ``` The supported pins are MLX LM 0.31.3, MLX 0.31.2 and Transformers 5.4.0. Keep those packages in the agent's environment; an unrelated global pip installation is not a repair for it. [Python environment behavior](https://docs.python.org/3/library/venv.html) ## Check free disk and the pinned model download Installation requires at least 26 GB free. Model downloads also require the selected approximate weight size plus 10 GB on the cache volume. `HF_HOME` or `HF_HUB_CACHE` can place it on a different disk. Larger models need more headroom. [Agent disk checks](https://agents.proxies.sx/compute/compute-agent.js) A repository directory can exist while its requested revision is incomplete. The agent checks the snapshot's configuration and weight files before serving it. Compare the expected immutable hash with the [catalog revision](https://www.proxies.sx/compute/models). [Hub download documentation](https://huggingface.co/docs/huggingface_hub/guides/download) Preserve the first redacted error and check connectivity to that repository. Allow advancing downloads to finish. Do not delete the entire shared cache as a routine fix; other applications may use it. ## Check the local model endpoint The default server listens only on loopback port 8734. Substitute a configured `MLX_PORT` if different: ```sh curl --fail --show-error --max-time 5 http://127.0.0.1:8734/v1/models ``` A successful response means a local server answered. Its served model must match the assigned snapshot; another process on that port is not readiness evidence. The agent refuses to kill an unrelated process using the port. Do not start another model server there. A refused connection is a runtime observation, not proof that the account key is wrong. ## Match the dashboard state to the next check | Observation | Next check | | --- | --- | | No registered node | Check safe doctor output, service status and registration errors; avoid duplicate installs. | | Downloading or loading | Check progress, the first error, cache space, exact revision and memory. | | Ready locally, offline in the portal | Keep the Mac awake and check heartbeat connectivity. Three minutes without a valid heartbeat is offline. | | paused_battery or paused_thermal | Connect power or address cooling, then inspect the next reported state. | | benchmark_required | Keep the Mac free and the exact model ready for automatic measurement. | | admission.benchmarkPending is true | A job is queued or running. Wait for its result; pending is not a pass. | | awaiting_approval | Ensure the measured model is ready and agreement current/countersigned, then await admin review. | | blocked | Admin review is required; a heartbeat or passing diagnostic does not clear the block. | | approved but not rentable | Review listing intent, current readiness, agreement and rental/benchmark occupancy. | | Repeated runtime errors | Preserve the first redacted error; do not repeatedly restart the service. | Admission requires a valid passing measurement no more than 24 hours old. Missing, invalid or expired measurements are automatically refreshed for eligible free ready unapproved nodes, with at least an hour between attempts. `admission.automaticBenchmark` means eligible, not queued. Already approved free nodes use a seven-day maintenance interval; expiration of the 24-hour admission window alone does not revoke approval. A larger model can require remeasurement. No automatic benchmark interrupts an occupied or admin-blocked node. Generic `verified` is not Compute approval. Listing intent alone is not marketplace capacity. Admin approval checks the exact measured model's current readiness, the valid measurement and current countersigned agreement. [Admission reference](https://agents.proxies.sx/compute/skill.md) ## Collect useful evidence for support Inspect a small relevant excerpt from `~/Library/Logs/proxies-compute.log` locally. Runtime errors can contain customer text. Redact credentials, personal paths, customer prompts and unrelated data before sending a farmer support ticket. Include observation time, matching device ID, agent/macOS version, chip/RAM, model state, safe doctor code, admission/pending state and whether a rental is affected. The generation deadline is 175 seconds with a 60-second gap-without-output limit; the API's default request deadline is 180 seconds. These are recovery limits, not latency or throughput promises. Use the [benchmark worksheet](https://www.proxies.sx/compute/benchmarks) to record prompt/output size and concurrency for workload timeouts. Report each observed gate and its next action to the owner. If admin review is pending, keep the Mac ready and state that review is pending. After approval, review the admin-set price/share, enable List for rent and confirm the actual state. Do not report onboarding, paid demand or payout as complete merely because the local service runs. --- # Check data privacy before renting an LLM inference endpoint Canonical: https://www.proxies.sx/compute/inference-privacy Audience: Renters Product reviewed: 2026-09-16 A dedicated machine reserves capacity for a customer. To assess privacy, also establish where prompts go, who operates the hardware and what happens to request data after generation. ## Trace the prompt beyond your application. Prompts pass through the platform relay and a supplier-administered Mac. Dedicated tenancy limits who rents that capacity; it does not make the supplier host confidential computing. - Normal completed-content relay scrub: ~1 hour - Job-record expiry, with cleanup lag: ~24 hours - Machine administration: Supplier-owned 1. Your application: Select permitted text. Check your own logs, stored conversations and fallback destinations. 2. Platform relay: Temporary relay storage supports request delivery. Published cleanup windows are not zero retention. 3. Supplier Mac: The supplier administers the hardware. The agent does not intentionally log prompts. 4. Response and saved copies: The answer returns to your application. Its retention policy is separate from relay cleanup. Documented data path. Backend deletion and supplier-host behavior were not independently audited. No confidential-computing or compliance certification is established here. [Current product reference](https://agents.proxies.sx/compute/facts.json), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## Trace the request to the provider's Mac The published PROXIES.SX flow sends a customer's request through the compute API, delivers inference jobs to a provider agent and runs the model on that provider's Apple Silicon Mac. The agent posts generated results back to the platform. This describes the application flow visible in public materials; it is not a complete audit of backend storage or infrastructure. [Provider documentation](https://agents.proxies.sx/compute/), [agent source](https://agents.proxies.sx/compute/compute-agent.js) ```text Your application -> PROXIES.SX compute API and job delivery -> provider Mac and local MLX model server -> result returned through the platform -> your application ``` A document excerpt included in a prompt becomes part of that request. Keeping the full document database on your own server does not keep the selected excerpts there. The same applies to conversation history, tool results and identifiers added by your application. ## Separate dedicated capacity from data protection Single-customer rental describes allocation. The supplier owns and administers the Mac, including its operating system and memory. This service does not provide confidential computing or independently attested execution. The current customer documentation explicitly describes temporary relay retention. HTTPS protects the network connection to the endpoint. Binding the local model server to loopback limits its network exposure. Neither establishes who can inspect data inside the machines processing it. | Property | Evidence to request before relying on it | | --- | --- | | Request retention | How the published relay windows apply to failed jobs, operational logs and backups. | | Operator access | Which platform and node operators can access requests or stored outputs. | | Training use | Whether prompts and completions can be used for model training or evaluation. | | Location | Where the assigned machine and any additional data processing take place. | | Deletion | How deletion is requested and what it covers, including backups. | | Incident handling | A contact and process for suspected data exposure. | These questions concern the coverage and enforcement of the published policy. A stated relay cleanup window does not answer every question about application logs, backups or access inside the supplier machine. ## Read the published relay retention windows The agent does not intentionally persist prompts, but runtime and diagnostic errors can contain sensitive text. The supplier still administers the Mac, so this behavior does not establish everything the host retains. The customer documentation describes relay storage used to deliver prompts and responses, with completed-job content normally scrubbed after one hour and job records expiring after 24 hours, subject to database cleanup timing. [Provider privacy description](https://agents.proxies.sx/compute/), [customer retention description](https://compute.proxies.sx/docs) The one-hour window describes normal cleanup of completed jobs, not a guarantee that every copy disappears exactly sixty minutes after a request. Database cleanup, failed jobs, application logs and supplier-host copies need separate consideration. This is not a zero-retention service. Trace your own application copies too. A saved conversation, an error report or a tracing service can retain text after the inference relay has removed it. Decide what each system needs and set its retention accordingly. A confidential workflow needs evidence covering the whole request path. ## Keep credentials and unnecessary data out of prompts Call the rental API from your application backend and keep the account key there. A browser-delivered bundle can expose embedded credentials to its users. The [API guide](https://www.proxies.sx/compute/api) explains the documented header and rental-specific endpoint. Prepare a sample request and inspect everything it contains before allowing real application traffic. Remove account secrets, unrelated conversation history and document sections that the task does not need. If a task only needs an order status, consider supplying the status and an internal reference instead of the customer's full record. Record operational metrics such as duration and status separately from prompt text. Debug logging is an application choice: check your SDK, proxy, error tracker and tracing configuration as well as the inference service. ## Check retrieval and fallback paths For a [RAG application](https://www.proxies.sx/compute/rag-inference), enforce document access before selecting excerpts for the model. A user must not receive another user's document through retrieval, even if the final answer is well written. Keeping access checks in application code makes that boundary independent of the model's response. A fallback can introduce another processor. If an offline node causes your code to send the same prompt to a second model service, review that destination under the same data-handling requirements. Do not silently broaden where confidential requests are sent. External documents can also contain instructions aimed at the model. OWASP describes this as indirect prompt injection and notes that RAG does not remove the vulnerability. Treat retrieved content as input data, and enforce tool permissions in application code. This reduces potential impact; a prompt instruction alone does not guarantee containment. [OWASP prompt injection guidance](https://genai.owasp.org/llmrisk/llm01-prompt-injection/) ## Choose inputs that match the evidence Public product descriptions, synthetic test cases and approved non-sensitive documents can help evaluate a model while data-handling questions are resolved. If your workload depends on a specific privacy guarantee, obtain supporting terms and technical evidence before sending it. The [rental guide](https://www.proxies.sx/compute/rent) covers availability and workload fit. For the service's current setup references, use the [agent documentation hub](https://agents.proxies.sx/) and [compute provider documentation](https://agents.proxies.sx/compute/). --- # Choose between 4-bit, 8-bit and bf16 LLM inference Canonical: https://www.proxies.sx/compute/quantization Audience: Renters Product reviewed: 2026-09-16 Fewer bits can reduce model weight storage, but the useful choice depends on the answers your application needs. Compare quantizations with the same tasks before paying for a larger machine. ## Compare capacity without assuming a quality ranking. BF16 is a 16-bit format. The catalog pairs its three weight formats with specific memory and context limits; those configurations do not prove a universal speed or quality hierarchy. - Reviewed weight formats: 4 / 8 / 16 bits - For meaningful quality comparisons: Same prompts - KV cache and working memory: Separate state Published catalog requirements, not benchmark results. The 4-bit context limit belongs to this configuration; it is not a general law of quantization. [Live model catalog](https://api.proxies.sx/v1/peer/compute/catalog), [MLX LM quantized inference](https://github.com/ml-explore/mlx-lm) ## What changes when model weights use fewer bits Quantization represents model weights with fewer bits. That reduces the space used by those weights and changes their numerical representation. The total runtime memory still includes other allocations, such as context state and temporary work. MLX LM supports model conversion and quantized inference on Apple Silicon. [MLX LM documentation](https://github.com/ml-explore/mlx-lm) A 4-bit label does not specify total serving memory. Check the quantization method, model architecture, runtime and context as well. The [Apple Silicon memory guide](https://www.proxies.sx/compute/apple-silicon) explains the difference between a raw weight estimate, download size and usable serving capacity. ## What research establishes Dettmers and Zettlemoyer's ICML 2023 study compared the relationship between model size, weight precision and zero-shot accuracy across several model families. Its results support evaluating 4-bit models when memory is constrained. The experiments covered BLOOM, OPT, NeoX/Pythia and GPT-2; they do not establish the quality or speed of the Qwen3.8 variants in the PROXIES.SX catalog. [The case for 4-bit precision](https://proceedings.mlr.press/v202/dettmers23a.html) Do not turn a general research finding into a fixed percentage of quality loss for your application. A model can pass a broad test and still fail a particular extraction format, language or coding task. A 2025 profiling study by Benazir and Lin tested several Apple Silicon and NVIDIA configurations and examined dequantization overhead alongside memory and compute limits. It reports that lower weight precision does not consistently produce faster inference across hardware. Its configurations do not establish performance for this rental catalog. [Apple Silicon quantization profiling](https://arxiv.org/abs/2508.08531) ## What the compute catalog establishes The [live catalog](https://api.proxies.sx/v1/peer/compute/catalog) lists three Qwen3.8 27B configurations. Its 4-bit entry requires 24 GB and publishes a 16,384 context limit; 8-bit requires 48 GB and bf16 requires 96 GB, both with 32,768 context. These are service fields, not measured comparisons. Exact repository names and download sizes are in the [model catalog guide](https://www.proxies.sx/compute/models). The context limits belong to these published configurations; 4-bit quantization does not inherently halve context capacity. BF16 stores values in a 16-bit floating-point format. Its catalog label describes the weights, not the precision of every runtime calculation. ## Separate weight precision from context settings MLX LM documents prompt caching, a rotating KV cache and configurable prefill steps. These affect how the runtime handles context and memory. They are separate from converting model weights to a lower precision. [MLX LM context features](https://github.com/ml-explore/mlx-lm#long-prompts-and-generations) A managed rental does not give you direct control over every runtime option. Compare the configuration the endpoint actually exposes. Keep model revision, input text, output cap and generation settings constant when evaluating precision; record an unavailable setting as unknown. Suppose an extraction test fails an exact number. Save that case and check whether the same failure occurs with each precision before attributing it to quantization. A prompt-format error, missing evidence or tokenizer difference can affect the result as well. For [RAG](https://www.proxies.sx/compute/rag-inference), use the same retrieved passages in each run. Choose the lowest-cost configuration that passes your task and capacity requirements. That is an application decision from your measurements, not a universal ranking of 4-bit, 8-bit and bf16 models. Use [cost per accepted result](https://www.proxies.sx/compute/pricing#calculate-cost-per-accepted-result) when failed outputs require retries or review. ## Compare quality before throughput Build a small saved evaluation set from your real tasks. Include exact-answer cases, long inputs and cases where the correct behavior is to say the available information is insufficient. Establish the pass condition before seeing model outputs. | Task | Check beyond whether the answer sounds plausible | | --- | --- | | Structured extraction | Required fields, source-backed values and handling of missing data. | | Code generation | Compilation, relevant tests and behavior on invalid inputs. | | Document answers | Correct source references, unsupported statements and refusal when evidence is absent. | | Classification | Per-category errors, especially the mistakes that cost the most to correct. | Keep the base model, prompt set, chat template and sampling settings as comparable as the service allows. Record any field you cannot inspect. Compare the same context length first; otherwise a change in retrieved evidence can be mistaken for a quantization effect. For a [RAG workload](https://www.proxies.sx/compute/rag-inference), test retrieval separately. More precise model weights cannot recover a document your retriever never supplied. ## Measure latency on the actual configuration Run timing tests only after defining acceptable task quality. Record first-token latency, completion time, errors and concurrency with the [benchmark worksheet](https://www.proxies.sx/compute/benchmarks). A shorter weight representation does not prove a particular speedup on a given Mac and runtime. If the 4-bit and 8-bit endpoints run on different chips, describe the result as a comparison of those complete configurations. It cannot isolate the effect of quantization. Keep output lengths comparable so a shorter answer does not appear faster simply because it contains less work. ## Choose the smallest configuration that passes Start with a configuration whose documented memory and context limits fit the task. If it passes your quality and latency requirements, a larger allocation needs a concrete benefit to justify its [rental cost](https://www.proxies.sx/compute/pricing). If it fails, inspect the failed examples before assuming precision is the cause. A different prompt, better retrieval or a different base model may address the failure. Those options require their own test; the current managed service is limited to its published catalog and assigned model. Check [current machine listings](https://compute.proxies.sx/models) before scheduling any comparison. Use your own comparable measurements before drawing a performance or quality conclusion. --- # Plan RAG inference hosting on a dedicated Mac endpoint Canonical: https://www.proxies.sx/compute/rag-inference Audience: Developers Product reviewed: 2026-09-16 A RAG application retrieves relevant source material and supplies it to a language model. A managed chat endpoint can provide the generation step while your application retains the document index and retrieval logic. ## Reserve context for the answer as well as the evidence. Your application handles ingestion, retrieval and document permissions. The rented endpoint generates text from the excerpts you send. Budget instructions, history, retrieved text and output together. - Catalog context limits: 16,384 / 32,768 - Maximum requested output: 4,096 tokens - Retrieval and access checks: Application-owned An editable planning example, not a tokenizer or an acceptance guarantee. The API also enforces a conservative input-byte budget. Retrieved text remains untrusted input. [Live model catalog](https://api.proxies.sx/v1/peer/compute/catalog), [Current product reference](https://agents.proxies.sx/compute/facts.json) ## Separate retrieval from generation The original retrieval-augmented generation research combined a retrieval component with a language generator for knowledge-intensive tasks. In an application design, it is useful to examine those stages separately: finding suitable evidence and generating an answer from it can fail for different reasons. [Lewis et al., Retrieval-Augmented Generation](https://arxiv.org/abs/2005.11401) For PROXIES.SX, the documented rental exposes model inference through a chat-completions API. It does not give the renter a shell for installing a vector database. The current API supports text chat completions, with no managed embeddings, indexing or reranking endpoint. Plan those components separately. [Compute rental documentation](https://compute.proxies.sx/docs) ```text Documents -> ingestion and index you operate Question + user permissions -> retrieval you operate Question + permitted excerpts -> rented chat inference endpoint Answer + source checks -> your application response ``` This is a proposed application architecture, not a deployed PROXIES.SX RAG service. Start with the [compute API integration](https://www.proxies.sx/compute/api) to establish the supported request shape. ## Decide what stays in your application Keep document ingestion, access permissions, retrieval and source identifiers in your backend. If you use an embedding model, confirm its license and hosting requirements separately. A chat-compatible endpoint does not imply an embeddings-compatible endpoint. Give each retrieved excerpt a stable document identifier and a location such as a section or page. Preserve the mapping in your application so a response can link to the source the user is allowed to read. Avoid asking the language model to invent a source URL. For changing documents, decide how updates and deletions reach the index. An accurate generator can still answer from an outdated excerpt. Store the document version or retrieval timestamp with an evaluation case so you can distinguish stale evidence from a model mistake. ## Budget the complete context Count the question, instructions, conversation history, excerpts and planned output against the assigned configuration's context limit. The [supported catalog](https://www.proxies.sx/compute/models) publishes 16,384 for the 4-bit entry and 32,768 for the other two. Confirm the current endpoint's behavior before relying on the full limit. The API also applies a conservative byte-based check: total UTF-8 message content bytes plus 64 per message, plus 256 for formatting, plus the requested output-token cap must fit the catalog context limit. For one message containing 12,000 UTF-8 bytes and an output cap of 2,000, the checked total is 14,320 against the 16,384 limit. This is validation arithmetic, not a workload recommendation or a claim that bytes equal tokens. Budget the actual tokenized context too; 12,000 input tokens may fail the byte check even when they fit a token-only calculation. Select excerpts by relevance and remove duplicates before expanding the prompt. Extra material has a cost in prompt processing and can make it harder to diagnose why an answer failed. Compare [quantizations](https://www.proxies.sx/compute/quantization) on the same evidence set. ## Check citations against the retrieved evidence Ask for source identifiers beside factual claims, then validate that each identifier came from the retrieved set. A valid identifier is only the first check: the cited passage must also support the claim. Create evaluation questions with known answers and include questions whose answers are absent from the indexed material. Record retrieval success, answer correctness, source support and unsupported claims separately. If the right passage was never retrieved, increasing inference capacity does not fix that failure. The [benchmark worksheet](https://www.proxies.sx/compute/benchmarks) can record model timing. Add your retrieval duration and source-check result alongside it to measure what the reader actually experiences. ## Test evidence position and missing answers Liu and colleagues' 2023 study found that performance on its retrieval and question-answering tasks could change when relevant evidence moved within a long context. The tested models do not establish a failure rate for this catalog. The finding supports adding position changes to your own evaluation. [Lost in the Middle](https://arxiv.org/abs/2307.03172) Take a question with one known supporting passage. Test the passage near the beginning, middle and end of the supplied excerpts, then remove it entirely. Keep the question and answer check fixed. This helps distinguish a model that uses supplied evidence from one that produces a plausible answer without it. | Evaluation case | Useful outcome to inspect | | --- | --- | | Correct passage retrieved | Answer matches the passage and cites its real identifier. | | Passage missing | The application reports that the indexed evidence is insufficient. | | Two document versions disagree | The answer uses the intended version or explains the conflict. | | Passage exists but user lacks access | Retrieval excludes it before inference. | For changing material, preserve the source version with the test case. Rerun retrieval checks after indexing changes and generation checks after model or prompt changes. This keeps a faster endpoint from masking an outdated or incorrectly permissioned index. The [model catalog](https://www.proxies.sx/compute/models) exposes revision hashes for repeatable generation comparisons. ## Enforce permissions before model access Filter retrieval by the authenticated user's permissions before sending excerpts to the model. Do not rely on a system prompt to hide documents that the user should never have received. Treat retrieved text as external data. Instructions embedded in a document can try to redirect the model, and RAG does not eliminate that risk. Keep tool authorization in application code and test with adversarial documents as well as normal questions. [OWASP indirect prompt injection guidance](https://genai.owasp.org/llmrisk/llm01-prompt-injection/) Selected excerpts leave your application when sent to the inference service. Review the [inference privacy questions](https://www.proxies.sx/compute/inference-privacy), including logging and any fallback provider, before using confidential documents. ## Test demand before a 30-day commitment Measure retrieval time, first-token latency and completion time under the simultaneous traffic you expect. If a busy period queues requests, a fast single-user demonstration is insufficient evidence for launch. Compare the [full rental cost](https://www.proxies.sx/compute/pricing) with the amount of successful work completed, and include the index, embedding service and application hosting in your own budget. Choose a supported model and check its [current compatible stock](https://compute.proxies.sx/models) before depending on a rental. A catalog entry, tier quote or account top-up does not reserve capacity. Use the [agent documentation hub](https://agents.proxies.sx/) for the wider service references and [compute provider reference](https://agents.proxies.sx/compute/) for how the model is served. This guide specifies an architecture and evaluation method; it does not report a tested RAG deployment. --- # Which Mac mini configurations can supply AI inference Canonical: https://www.proxies.sx/compute/mac-mini Audience: Providers Product reviewed: 2026-09-27 A Mac mini qualifies by its configured memory, not its name. The 16GB standard configuration is below the 24 GB minimum; the largest option, 64GB, fits the 4-bit and 8-bit configurations but not BF16. ## The standard 16GB Mac mini is below the 24 GB minimum. Apple lists Mac mini memory from 16GB to 64GB. Options from 24GB fit the 4-bit configuration, 48GB and 64GB also fit 8-bit, and no listed Mac mini reaches the 96 GB that BF16 requires. - Standard memory on Models 1 and 2 (does not qualify): 16GB - Largest Mac mini memory Apple lists: 64GB - Catalog memory requirements: 24 / 48 / 96 GB Catalog memory requirements. Apple configurations are from its Mac mini specification page, read 27 September 2026; fitting memory is not an admitted tier or a benchmark result. [Apple Mac mini technical specifications](https://www.apple.com/mac-mini/specs/), [Compute operation reference](https://agents.proxies.sx/compute/skill.md) ## What Apple currently lists Apple's Mac mini technical specifications, read on 27 September 2026, list four configurations. Models 1 to 3 use the Apple M6 chip; Model 4 uses the Apple M5 Pro chip. Larger memory and storage are configure-to-order options. [Apple Mac mini technical specifications](https://www.apple.com/mac-mini/specs/) | Apple configuration | Chip | Standard memory | Memory options | Standard storage | | --- | --- | --- | --- | --- | | Model 1 | M6 | 16GB | 24GB or 32GB | 256GB SSD | | Model 2 | M6 | 16GB | 24GB or 32GB | 512GB SSD | | Model 3 | M6 | 24GB | 32GB | 512GB SSD | | Model 4 | M5 Pro | 24GB | 48GB or 64GB | 512GB SSD | ## Map each memory option to the compute gates A compute supplier needs at least 24 GB of unified memory. The catalog serves Qwen3.8 27B in three configurations: 4-bit needs 24 GB, 8-bit needs 48 GB and BF16 needs 96 GB. [Compute prerequisites and catalog](https://agents.proxies.sx/compute/skill.md) | Mac mini memory | Where Apple offers it | Meets the 24 GB minimum | Catalog configurations that fit memory | | --- | --- | --- | --- | | 16GB | Standard on Models 1 and 2 | No | None | | 24GB | Standard on Models 3 and 4; option on Models 1 and 2 | Yes | 4-bit | | 32GB | Option on Models 1, 2 and 3 | Yes | 4-bit | | 48GB | Option on Model 4 | Yes | 4-bit and 8-bit | | 64GB | Option on Model 4 | Yes | 4-bit and 8-bit | The 16GB standard memory of Models 1 and 2 does not qualify. The largest memory Apple lists for a Mac mini is 64GB, so no Mac mini on the current spec page reaches the 96 GB that the BF16 configuration requires. Fitting a configuration's memory is a prerequisite, not an admitted tier. Admission also needs a signed and countersigned agreement, a passing benchmark and explicit admin approval. [Admission steps](https://agents.proxies.sx/compute/) ## Plan the disk, not only the memory The installer requires at least 26 GB free. The model downloader separately checks the selected model's approximate weights plus 10 GB on its cache volume: 26 GB for 4-bit, 40 GB for 8-bit and 65 GB for BF16. The agent normally chooses the largest catalog model that fits memory, so a 48GB or 64GB Mac mini normally selects 8-bit and needs the larger margin. [Disk requirements](https://agents.proxies.sx/compute/skill.md) Apple states storage in decimal units (1GB is one billion bytes) and notes that formatted capacity is lower. macOS and your own files use part of it, so read the actual free space with `df -h "$HOME"` rather than the configuration's storage figure. ## The rest of the checklist The chip and memory are only part of the requirement. The Mac also needs macOS 14 or later, native arm64 Node.js 18 or later and native arm64 Python 3.10 or later. Intel and Rosetta are not supported, which also rules out Intel Mac minis. For a Mac mini you already own, apply the same gates to its configured memory, shown in About This Mac. The [Mac compute eligibility checker](https://www.proxies.sx/tools/mac-compute-checker) compares every value and lists the requirements that fail. Keep the Mac powered, awake and connected. The agent's launchd service starts at login, and a Mac that misses heartbeats for three minutes is shown offline. [Agent operation](https://agents.proxies.sx/compute/) ## What this guide does not measure We did not install the agent on a Mac mini or benchmark one. Apple publishes memory bandwidth for each chip, but a bandwidth figure is not an inference result. Measure response time and memory pressure on the actual machine with the [benchmark worksheet](https://www.proxies.sx/compute/benchmarks), read the [Apple Silicon memory guide](https://www.proxies.sx/compute/apple-silicon) for how weights and context share memory, and read [renting out your Mac safely](https://www.proxies.sx/compute/renting-out-your-mac-safely) before you install. --- # Renting out your Mac for AI inference: what runs and how to stop it Canonical: https://www.proxies.sx/compute/renting-out-your-mac-safely Audience: Providers Product reviewed: 2026-09-27 The agent serves one model on a local-only port, carries no proxy traffic and can be paused or removed with one command. It is not confidential computing, and a listed Mac is not guaranteed rentals. ## A local-only model server you can pause or remove. The agent serves one pinned model with MLX on 127.0.0.1:8734 and carries no proxy traffic. It is not confidential computing, rentals are not guaranteed, and --remove refuses only while a customer rents the Mac. - Local MLX listener: 127.0.0.1:8734 - During early access: No SLA - Pause or leave for good: --uninstall / --remove 1. Read the source: The agent is readable Node.js with no npm dependencies. Enter the supplier key only at its hidden prompt. 2. Know what runs: A private Python/MLX runtime and a launchd service that starts at login, serving one model on a local port. 3. Know what is not promised: No guaranteed rentals or payouts and no availability SLA. You cover electricity, connectivity and hardware. 4. Stop when you choose: Pause with --uninstall or leave with --remove. A rented Mac cannot be removed mid-rental; open a support ticket. Summarised from the compute operating guide. We did not install the agent for this review. [Compute operation reference](https://agents.proxies.sx/compute/skill.md), [Provider documentation](https://agents.proxies.sx/compute/) ## What the agent installs The compute agent is readable Node.js source with no npm dependencies. Read it before you run it. [Compute agent source](https://agents.proxies.sx/compute/compute-agent.js) Before changing anything, the installer validates your supplier key. It then creates a private Python environment with mlx-lm 0.31.3, MLX 0.31.2 and Transformers 5.4.0, so no global pip installation is needed. It stores the key in `~/.proxies-compute/config.json` with mode 600, copies itself to `~/.proxies-compute/compute-agent.js` and loads your user's `sx.proxies.compute` launchd service, which starts at login. [Installation reference](https://agents.proxies.sx/compute/skill.md) ## What runs and what it listens on In the words of the operating guide: "It serves one pinned catalog model using MLX on `127.0.0.1:8734`; it does not open a public MLX listener or carry proxy traffic." It downloads the model weights into the Hugging Face cache, checks a startup generation before reporting ready, and refuses to kill an unrelated process that already uses that port. - It registers the chip, RAM, core count, macOS version and the Mac's hostname, which becomes the node's name. - It sends a heartbeat every 60 seconds with model state, served models, version and free disk. - It handles one job at a time, stops generation at 175 seconds or after 60 seconds without output, and stops when a rental claim becomes invalid. - It checks power every minute and pauses below 20% battery when unplugged or below a 50% thermal CPU limit, resuming when the condition clears. Renters receive managed inference access, not SSH, remote desktop, a shell or containers on your Mac. [Agent operation](https://agents.proxies.sx/compute/) ## What it is not The endpoint is not confidential computing. You own and administer the Mac, including its operating system and memory, and customer prompts pass through the platform and your Mac's runtime. The agent does not intentionally persist prompts, but runtime errors can contain sensitive data, so do not publish logs wholesale. Redact keys, personal paths and model text from any excerpt you share with support. ## What is not promised A listed Mac is not guaranteed rentals or payouts, and early access has no availability SLA. You cover electricity, connectivity and hardware. Installing does not admit a Mac: admission needs a signed and countersigned Partner Agreement, a passing benchmark and explicit admin approval, and complimentary rentals generate no paid-rental share. [Supplier terms](https://agents.proxies.sx/compute/) ## Keep the key off screen Enter the Compute supplier key only at the installer's non-echoing prompt. Never paste it into a chat, a command or a screenshot, and never print `config.json`, `state.json` or environment variables, which can hold keys and device tokens. An account can hold five active API keys; keep any key another working Mac uses. ## Pause or leave at any time The guide states: "Your Mac is yours. You can pause or leave at any time, without asking us and without a notice period. The only thing that blocks removal is a customer renting the machine at that moment." ```sh # Pause: keeps identity, runtime and models node "$HOME/.proxies-compute/compute-agent.js" --uninstall # Leave for good (agent 0.3.3 or newer; the first line fetches it) curl -fSLo /tmp/compute-agent.js https://agents.proxies.sx/compute/compute-agent.js node /tmp/compute-agent.js --remove ``` | | Pause: --uninstall | Leave for good: --remove | | --- | --- | --- | | Node on PROXIES.SX | Stays in the dashboard, offline, not rentable | Deleted: no longer listed, rentable or counted | | launchd service | Stopped and unloaded | Stopped and unloaded | | Saved API key | Deleted | Deleted | | Device identity | Kept: a re-install is the same node | Deleted: a later install is a new node | | Private Python/MLX runtime (about 1 GB) | Kept | Deleted | | Downloaded catalog model (16-55 GB) | Kept | Deleted; other models in the Hugging Face cache are not touched | | Earnings already recorded | Unchanged | Unchanged | An occupied Mac cannot be removed mid-rental: `--remove` stops with a message and deletes nothing while a customer rents the Mac. Wait for the rental to end, or open a farmer support ticket to have the customer moved. For any maintenance on a rented Mac, including stopping, reinstalling or replacing credentials, arrange it through a farmer support ticket first. If PROXIES.SX cannot be reached, `--remove` still cleans the Mac and tells you to delete the node in the farmer portal. Afterwards, revoke the API key under API keys, because a key cannot revoke itself. [Pause and removal](https://agents.proxies.sx/compute/skill.md) ## Before you install Check the prerequisites with the [Mac compute eligibility checker](https://www.proxies.sx/tools/mac-compute-checker). If you are choosing hardware, the [Mac mini configuration guide](https://www.proxies.sx/compute/mac-mini) maps Apple's memory options to the catalog. The [provider setup guide](https://www.proxies.sx/compute/providers) covers the account, agreement and key, and [provider troubleshooting](https://www.proxies.sx/compute/provider-troubleshooting) covers a Mac that stops progressing.