Host a GPU Get Started
Now in Early Access

The load is split.
Friends help.

Run frontier MoE models for $15/mo. Or lend your GPU and earn money while it idles. One network, two sides of the same coin.

64.5% Prefill speedup
Free 14-day trial
70% Host earnings
Start Free Trial Earn With Your GPU
For GPU Owners
Your idle GPU earns money while you sleep
One command. No Docker, no Kubernetes, no manual config. Sawyer handles routing, health monitoring, and payouts. You just run it.
# Register your GPU and start earning
$ sawyer register --email you@example.com
$ sawyer serve --gpu

Sawyer Node Started
  Node:       sawyer-node-abc123
  Experts:    mixtral-8x7b/e2, mixtral-8x7b/e5
  GPU:        NVIDIA RTX 3090 (24 GB)
  Status:     Healthy
  Earnings:   $0.00

70% Revenue Share

Of every token your node serves, you keep 70%. The other 30% covers routing, infrastructure, and network operations. No hidden fees, no minimums beyond the $10 payout threshold.

RTX 3090 (24 GB) $40 – $120/mo estimated
RTX 4090 (24 GB) $60 – $180/mo estimated
RTX 3060 (12 GB) $15 – $50/mo estimated

How Payouts Work

Monthly payouts via Stripe Connect. Hit $10 and you get paid. Quarterly payouts at $25 threshold. 1099-K tax forms are generated automatically -- no invoicing, no chasing payments.

  • Stripe Connect Express onboarding (KYC handled)
  • Bank account verification in minutes
  • Automatic 1099-K for US-based hosts
  • Payout dashboard tracks every token served

What You Need

  • NVIDIA GPU with 6 GB+ VRAM and CUDA 12+
  • Stable internet (5 Mbps+ upload)
  • ~3 GB disk per expert weight file
  • No Docker, no Kubernetes, no config files

Your node serves only the experts you consent to. Bedrock identity tokens audit-log every request for accountability. You own your hardware -- always.

Architecture
Mixture-of-Experts, Distributed
MoE models activate only 25% of parameters per token. Each expert is independent, so they split across consumer GPUs naturally. No tensor parallelism required.

Router

Receives your request, runs the gating network locally, and activates only the 2-6 relevant experts across the network. Aggregates the results back to you.

Expert Nodes

Each volunteer GPU hosts 1-3 expert weight files (~1.5GB each for Mixtral). A single RTX 3090 can serve inference requests while you game or work.

Bedrock Identity

Every node holds a cryptographic identity from Bedrock. Consent tokens gate which models a node will serve. Every inference is audit-logged.

Token Economics

14-day free trial with unlimited tokens. Then Pro at $15/mo for 2M tokens. 70% goes to the hosts who serve inference.

Smart Routing

Adaptive routing balances load (60%) and latency (40%). Falls back to redundant experts on timeout. No single point of failure.

Quantized Models

Q4_K_M quantization fits frontier models on consumer hardware. Mixtral-8x7B expert = ~1.5GB. Full model = ~24GB. Each piece runs independently.

Benchmark
64.5% faster MoE prefill. Measured, not claimed.
Sawyer Fast Llama pipelines expert uploads with compute, eliminating GPU idle time during Mixture-of-Experts inference. One command proves it.
# Install Sawyer
$ pip install sawyer-core

# Run the before/after benchmark
$ sawyer bench -m mixtral-8x7b-instruct-v0.1-Q4_K_M.gguf

Sawyer Bench — MoE prefill optimization comparison
  Model:   mixtral-8x7b-instruct-v0.1-Q4_K_M.gguf
  Binary:  ~/.sawyer/bin/sawyer-fast-llama-linux-x64

  Prefill (prompt processing):
  Test       Baseline      Optimized   Speedup      Change
  --------------------------------------------------------
  pp512      142.1 t/s     234.4 t/s     1.65x     +64.5%
  pp1024     128.7 t/s     213.8 t/s     1.66x     +66.2%
  pp2048     107.3 t/s     174.9 t/s     1.63x     +62.9%

  Average prefill speedup: 1.65x (+64.5%)
How It Works
From request to result in 5 steps
No setup required. Subscribe, get an API key, and send requests like any other inference API.

Subscribe

Start with a 14-day free trial. Unlimited tokens, no credit card. Then choose Pro ($15/mo), Pioneer ($40/mo), or Enterprise ($200/mo).

Send a Request

Use the Sawyer API like any inference endpoint. The router receives your prompt and token embedding.

Router Selects Experts

The gating network identifies which 2-6 experts are needed. Only those experts activate. The rest stay dormant.

Nodes Compute in Parallel

Expert nodes run forward passes concurrently. Average latency: 50-200ms per expert on consumer hardware.

Get Your Result

The router aggregates expert outputs and returns your response. Tokens are debited from your budget.

Hosts Get Paid

70% of what you spend goes to the nodes that served you. Monthly or quarterly payouts via Stripe Connect.

Pricing
14 days free. Then pick your plan.
Developers try for free. Production inference costs real money — and 70% of it goes to the hosts who make it possible. Three paid tiers: Pro, Pioneer, Enterprise.
Explorer
Free trial
14 daysfree
Unlimited tokens during trial
  • All supported models
  • Community support
  • Standard routing
  • No credit card required
  • Then choose Pro, Pioneer, or Enterprise
Start Free Trial
Pro
Production
$15/mo
2,000,000 tokens per month
  • All supported models
  • Token rollover (1 month)
  • Priority routing
  • Email support
  • CA-signed certificates
Get Started
Pioneer
Scale
$40/mo
5,000,000 tokens per month
  • All supported models
  • Token rollover (1 month)
  • Adaptive routing (priority)
  • Direct support
  • Custom deployment
Get Started
Enterprise
Unlimited
$200/mo
10,000,000 tokens per month
  • All supported models
  • Token rollover (1 month)
  • Dedicated routing
  • Priority support
  • Custom SLA
Contact Us

Already subscribed? Manage your subscription

Host a Node
One command. Real income. No hassle.
Already covered above in detail. Here's the short version: register, serve, get paid.

Register

$ sawyer register

Create your host identity, link your Stripe account, and download the CLI. Takes under 60 seconds.

Serve

$ sawyer serve

Download assigned expert weights and start serving inference. Sawyer handles routing, health checks, and weight updates automatically.

Earn

70%

Of every token billed goes to you. Monthly Stripe Connect payouts. 1099-K tax reporting included.

Control

Consent

Bedrock identity tokens gate which models your node serves. You choose what runs on your hardware. Every request is audit-logged.

FAQ
Frequently asked questions
Technical details, honest answers. If it's not covered here, ask us on GitHub.
Sawyer is a distributed inference network for Mixture-of-Experts (MoE) language models. Instead of running an entire model on one GPU, Sawyer splits the model's expert weights across many volunteer nodes. When you send a prompt, the router identifies which 2–6 experts are needed for that token, dispatches only those forward passes to the nodes holding the relevant weights, and aggregates the results. This avoids tensor parallelism entirely — each expert runs independently on whatever GPU it lives on.
Traditional APIs (OpenAI, Anthropic, Together) run the full model on their own GPU clusters and charge per token with no hosting option. Sawyer distributes the compute across a peer network of consumer GPUs, which is why we can offer a 14-day free trial and lower pricing. You can also host your own GPU and earn 70% of the inference revenue — no other major API lets you do that. The trade-off is that we currently support MoE models only, since their expert structure makes distributed inference practical.
We currently support Mixtral 8x7B (46.7B params, 8 experts), DeepSeek-V2 Lite (15.7B params, 64 shared experts), and Qwen2.5 7B MoE (14.3B params, 60 experts). All models run in Q4_K_M quantization. We're evaluating additional MoE architectures — if a model has a clear expert decomposition, it's a candidate for the network. Non-MoE dense models don't distribute well across consumer GPUs, so we don't support those.
Two commands: sawyer register creates your host identity and links your Stripe account for payouts. sawyer serve --gpu downloads the assigned expert weights and starts serving inference requests. The CLI handles health monitoring, weight updates, and routing registration automatically. You need an NVIDIA GPU with CUDA drivers and enough VRAM to hold your assigned experts (1.5–3 GB per expert). No Kubernetes, no Docker, no manual configuration.
You earn 70% of every token billed for inference your node serves. Earnings depend on your GPU's throughput and network demand — an RTX 3090 serving two Mixtral experts can realistically process hundreds of thousands of tokens per day. Payouts happen monthly via Stripe Connect once you hit the $10 minimum threshold. Quarterly payouts are available at a $25 threshold. Stripe handles 1099-K tax reporting automatically; you don't need to invoice us.
All traffic between the router and expert nodes uses CA-signed TLS certificates — no self-signed certs, no plaintext. Host nodes never see complete prompts; they receive only the embedding slices relevant to their assigned expert, making it computationally infeasible to reconstruct user input. Bedrock identity tokens audit-log every inference request for accountability. We don't store prompt content after delivery, and host nodes don't log token data.
The router tracks node health via heartbeat signals. When a node misses its heartbeat window, the router removes it from the active pool and redirects requests to redundant copies of the same expert running on other nodes. Smart routing weights its scoring 60% toward load balance and 40% toward latency, so there's always capacity headroom across the network. If no redundant expert is available, the request is queued until a healthy node picks it up — it doesn't fail silently.
You get 14 days of unlimited token usage across all supported models, no credit card required. After the trial ends, you choose Pro ($15/mo for 2M tokens), Pioneer ($40/mo for 5M tokens), or Enterprise ($200/mo for 10M tokens). Unused tokens on paid plans roll over for one month. If you decide not to continue, your account simply stops working — no charges, no cancellation needed.
Yes. Sawyer exposes an OpenAI-compatible API endpoint, so any code that works with openai (Python, JS, LangChain, LlamaIndex, etc.) works with Sawyer by changing the base URL and API key. That includes streaming, function calling, and structured output where the underlying model supports them. No SDK lock-in — if it speaks the OpenAI chat completions format, it works here.
Any NVIDIA GPU with at least 6 GB VRAM and CUDA 12+ drivers can host. A single Mixtral expert in Q4_K_M quantization is ~1.5 GB, so an RTX 3060 (12 GB) can hold two experts comfortably, and an RTX 3090 (24 GB) can hold four to six. You also need stable internet (5 Mbps+ upload) and enough disk space for the expert weight files. No specific CPU or RAM requirements — inference is GPU-bound.
Bedrock provides the cryptographic identity layer for every node on the network. When you run sawyer register, your node generates a keypair and receives a Bedrock-signed identity certificate. This certificate is used to authenticate every inference request your node serves and to verify that responses actually came from your node. Consent tokens — also managed through Bedrock — let you specify which models your node will serve, so you have explicit control over what runs on your hardware.
We use Q4_K_M quantization (4-bit with K-quants medium mix), which reduces model size by roughly 75% with minimal quality loss — typically under 1% degradation on standard benchmarks compared to FP16. This is what makes distribution practical: a Mixtral-8x7B expert drops from ~6 GB in FP16 to ~1.5 GB in Q4_K_M, fitting comfortably on consumer GPUs. The "medium" mix preserves important weight groups at higher precision, which is why Q4_K_M outperforms naive 4-bit rounding on perplexity and generation quality.
Supported Models
Frontier models on consumer hardware
Quantized MoE models that split across GPUs. Each expert runs independently, so the network scales horizontally.
Model Params Experts Active/Token Q4 Size Expert Size
Mixtral 8x7B 46.7B 8 2 ~24 GB ~1.5 GB
DeepSeek-V2 Lite new 15.7B 64 (shared) 6 ~9 GB varies
Qwen2.5 7B MoE 14.3B 60 4 ~7 GB varies
CLI
From zero to inference in 3 commands
# Create your account
$ sawyer account create --tier explorer

# Register your GPU as a host node
$ sawyer provider register --email you@example.com --name "MyNode"

# Start serving inference requests
$ sawyer serve --gpu

Sawyer Node Started
  Node:       sawyer-node-abc123
  Experts:    mixtral-8x7b/e2, mixtral-8x7b/e5
  GPU:        NVIDIA RTX 3090 (24 GB)
  Status:     Healthy
  Earnings:   $0.00
Get Started

Try frontier AI free for 14 days. Then subscribe to keep building.

No credit card required. Unlimited tokens during trial. Upgrade to Pro when you ship.

Start Free Trial View on GitHub