Enterprise Infrastructure as a Service

Deadwood handles the infrastructure.You handle the product.

Managed preference learning, enterprise SLAs, transparent pricing. Focus on your users—we operate the stack underneath.

Deadwood is infrastructure you buy, not build. Integrate our API, let your users train models, and we run orchestration, storage, delivery, settlement, scaling, backups, and security monitoring. You pay for measured usage on published tiers. We publish uptime and latency targets where you sign a production tier—no DIY servers, no midnight pager unless it is your product choice.

Request flow

Your product

Mobile · web · desk

Deadwood API

Auth · routing · metering

Everything behind the API

  • Training orchestration · checkpoint storage
  • Edge delivery · health monitoring
  • Settlement · backups · failover

Enterprise Deadwood infrastructure

Everything required to ship personalization—operated as a service, not a science project.

Managed API

Your users. Our edge.

HTTPS endpoints, routing, caching, and failover sit on our side. You integrate once; we absorb traffic spikes and maintain production hygiene.

Target uptime: 99.9% on paid tiers

Latency targets published per tier

Autoscaling request plane

Global delivery footprint

24/7 monitoring with routed alerts

Included

  • Managed TLS and rotation
  • Zero-downtime configuration pushes
  • Health checks with automatic reroute
  • Usage telemetry exposed to your dashboard

You skip

  • Provisioning VMs
  • Patching load balancers
  • Capacity spreadsheets

Serverless training

Users train. We execute.

Jobs spin up on demand, run isolated pipelines, persist checkpoints, and shut down idle workers—you pay for runtime and published token economics, not parked GPUs.

Elastic concurrent training jobs

Typical jobs finish in minutes, not days

Optional large-GPU paths on Autonomous

Reproducible manifests per run

Streaming logs for operators

Included

  • Queueing, retries, and backoff
  • Hardware-aware execution profiles
  • Automatic artifact packaging
  • Failure notifications to your channels

You skip

  • Kubernetes babysitting
  • Manual cluster sizing
  • Notebook-only drift

Global model storage

Train once. Serve everywhere.

Versioned weights live behind the API with immutable history. Hot copies fan out close to users; cold anchors exist for governance and disaster scenarios.

Unlimited logical versions (fair-use on Catalyst)

Replication across regions

Edge caching for low-latency inference

Git-adjacent audit trail

Long-horizon archival partners (contractual)

Included

  • Content-addressed bundles
  • Instant promotion between versions
  • Encrypted pipelines by default
  • Restore drills available on Autonomous

You skip

  • Self-managed object stores
  • Manual CDN wiring
  • Silent overwrite of weights

Transparent token billing

Pay for usage. See the ledger.

Calls and trainings meter into balances you can inspect in real time. Creator-market splits can ride the same rails when you enable marketplaces.

Per-call economics published upfront

Settlement batches or near-real-time by tier

Exports for finance teams

Spend alerts and caps

Optional royalty rails for creators

Included

  • Dashboards with attribution
  • Immutable receipts where enabled
  • Chargeback-friendly CSV exports
  • Tiered batching on free experiments

You skip

  • Surprise line items
  • Opaque GPU minute math

Enterprise security posture

Data stays governed.

Encryption in transit and at rest, tenant isolation, optional private networking, and audit trails sized for security questionnaires—not marketing promises.

Modern TLS everywhere customer-facing

Encrypted persistence layers

GDPR-aware processing; HIPAA paths via contract

Automated encrypted backups

Custom DPAs on Autonomous

Included

  • API key scoping and rotation guidance
  • Role separation inside workspaces
  • Immutable access logs (tiered retention)
  • Incident response runbooks

You skip

  • Shared passwords
  • Mystery admin access

Support & SLAs

Someone answers.

Operations engineers watch the fleet around the clock. Accelerator receives business-hour-plus urgent paths; Autonomous tightens response windows and adds named coverage.

Always-on automated alerting

Slack, email, or webhook routing

4-hour target on Accelerator incidents

1-hour executive paths on Autonomous

Public status communication

Included

  • Post-incident reviews on request
  • Cost and latency tuning guidance
  • Hands-on migration planning (Autonomous)
  • Roadmap briefings for strategic partners

You skip

  • Ticket black holes
  • Unsupported weekends on paid tiers

Compare at a glance

Three tiers by data scale and operations maturity. Premium is where most production teams land.

Feature

Local

Free forever

Premium

$99/month

Enterprise

Custom pricing

API calls / month
1,000
100,000
Unlimited
Model trainings / month
1
10
Unlimited
Training data source
Local files only
Local files + Snowflake
Local + Enterprise Snowflake + custom sources
Max training dataset
10K items (MB-scale)
1M items (GB-scale)
Unlimited (petabyte-scale)
Model ecosystem
Phi-3 (lightweight)
Phi, Falcon, Mistral, LLaMA
Full ecosystem + custom fine-tuning + proprietary models
Model storage
Public shared storage (no privacy)
Private floppydisk.cc (versioned, encrypted)
Dedicated floppydisk.cc + Filecoin backup + custom storage
On-chain settlement
Hourly token batches (daily ledger updates)
Real-time Avalanche (immediate transactions, immutable ledger)
Real-time (Cosmos or Avalanche—you choose)
Snowflake integration
None (local training only)
Your Snowflake instance (you pay Snowflake query costs)
Dedicated Snowflake cluster (unlimited queries included)
Training speed
Local compute (CPU only, 1–10 min per 10K items)
Cloud compute (serverless, 2–5 min per 1M items)
GPU-accelerated (20–60 min per 500B items, optional real-time)
Creator marketplace
View only (can use published models)
Publish & earn (70% revenue share on published models)
Premium publishing (featured placement, custom revenue split, direct creator relationships)
Compliance & certifications
Basic encryption (TLS in transit)
SOC 2 Type II, GDPR, encryption at rest + in transit
SOC 2 II, GDPR, HIPAA, FedRAMP (custom agreements)
Multi-team access
Single user only
Basic (2–3 team members, read/write)
Full RBAC (unlimited users, custom roles, SSO/SAML)

Local git workflow

Train locally, commit manifests, let floppydisk.cc pin artifacts, flip production in git, settle promotions on-chain.

Step 1: You train locally
├─ Run: deadwood train --config .deadwood.yml
├─ Local model trains on your data
└─ You validate it works

Step 2: You commit
├─ git add .deadwood.yml
├─ git commit -m "feat: trading_taste_v2 model, 98.2% accuracy"
└─ git push

Step 3: floppydisk.cc detects change
├─ Sees new model definition
├─ Trains trading_taste_v2 on remote GPUs (optional)
├─ Stores final weights on Filecoin
└─ Model is versioned, permanent, immutable

Step 4: You deploy
├─ Edit .deadwood.yml: set trading_taste_v2 to production: true
├─ git commit -m "deploy: trading_taste_v2 to production"
├─ git push
└─ Your app immediately uses new model (no downtime)

Step 5: Avalanche records it
├─ Transaction: "user_xyz swapped to trading_taste_v2"
├─ Timestamp: [timestamp]
├─ Model hash: [hash]
└─ Now immutably recorded

Result: New model in production. Perfect auditability. No manual deployment. No infrastructure thinking.

Before you widen traffic or flip production

Optimization and evaluation

Optimization buys more quality per dollar from the hardware you already have. Evaluation ties scores to the same commits as your weights—so promotions are measured, comparable, and explainable.

What Deadwood enables

Patterns we see once APIs land—your vertical names will differ, but the mechanics repeat.

Trading & markets

Problem

Generic signals frustrate distinct trader personas—risk tolerances differ wildly.

Deadwood layer

Preference models rank scenarios per user, lifting engagement without exposing proprietary execution logic outside your compliance perimeter.

  • Longer qualified sessions
  • Higher repeat usage
  • Lower churn among power users

Marketplaces & listings

Problem

Static sorting wastes buyer attention; agents burn cycles on poor-fit inventory.

Deadwood layer

Learn aesthetic and constraint preferences, surface better matches first, and shorten the path from browse to commitment.

  • Faster qualified conversations
  • Higher conversion on premium inventory
  • Better partner NPS

Interactive games

Problem

Uniform difficulty curves bleed casual and expert players alike.

Deadwood layer

Adapt pacing, seeds, and challenges from observed play styles—without shipping bespoke ML teams inside the studio.

  • Stronger DAU/WAU ratios
  • Longer sessions
  • Lift in monetization among engaged cohorts

Feeds & creators

Problem

One-size feeds collapse creator economics and tank engagement.

Deadwood layer

Rank with per-user taste models while preserving creator transparency—Deadwood handles training loops and delivery.

  • Higher meaningful interactions
  • Better creator retention
  • More efficient ad inventory

Transparent pricing

Published tiers, published overages, published SLAs—pick the envelope that matches your stage.

Catalyst

Free

Learn and prototype

  • 1,000 API calls / month
  • 1 training job / month
  • Community support
  • Basic telemetry
  • Batch settlement cadence

Smaller models · local data paths · fair-use guards

Accelerator

$99 / mo

Production teams

  • 100,000 API calls / month
  • 10 trainings / month
  • Private workspaces
  • Near-real-time settlement
  • Email + Slack · 4-hour targets

Snowflake-forward integrations · optional GPU surcharges

Illustrative overages: extra calls and trainings billed at published meter rates—see dashboard before invoice.

Autonomous

Custom

Enterprise scale

  • Unlimited usage envelopes
  • Dedicated compute + managers
  • Custom SLAs & residency
  • Advanced compliance packages
  • Roadmap collaboration

Starts around $500/mo for scoped pilots—final economics depend on data gravity

What you are actually paying for

Margins move with utilization. Here is the honest shape—not line-item invoices, but the cost buckets we manage so you do not have to hire a cloud economics team.

API & delivery plane

Managed ingress, autoscaling, observability, and incident staffing are bundled into subscription economics. At modest scale we intentionally run close to cost—margin expands as your usage depth grows.

Training & artifacts

Serverless execution keeps idle capacity off your books. Large GPU bursts map to token surcharges so finance can see exactly when heavyweight jobs occurred.

Data platforms

Shared metadata services amortize across tenants; premium isolation lands on Autonomous with explicit sizing so databases never become mystery spend.

Support & reliability engineering

Human coverage is priced into Accelerator and above. On smaller footprints we may subsidize support—Autonomous and strategic accounts fund the bench depth.

Archival & settlement

Long-horizon storage partners and ledger receipts add pennies per artifact but eliminate “single vendor amnesia.” We disclose those flows in enterprise reviews—not billboard marketing.

How Deadwood monetizes

We make money when you succeed at scale—subscriptions anchor the relationship, usage aligns incentives, and marketplace rails let creators participate without hiding economics.

1 · Subscriptions

Catalyst is deliberately lightweight—it lets you validate fit. Accelerator carries most product R&D. Autonomous concentrates margin so we can dedicate partitions, lawyers, and reliability engineers without pretending it is the same SKU.

2 · Metered overages

When you blow past inclusive quotas, incremental usage bills at published rates. Those increments fund burst capacity and keep baseline pricing approachable for early teams.

3 · Creator revenue share (roadmap)

When marketplaces go live, creators keep the majority of downstream token spend; Deadwood captures a platform fee that pays for trust, safety review, and settlement plumbing—never hidden inside inference pricing.

DIY vs. Deadwood (plain-language TCO)

Building preference infrastructure in-house means hiring specialists, stitching observability, and accepting outage risk. Buying Deadwood trades capex-like engineering spikes for predictable opex tied to usage.

Self-build trajectory

  • Multi-quarter engineering for API + training + delivery
  • Ongoing SRE coverage (nights and weekends cost real money)
  • Vendor sprawl: observability, secrets, artifact stores, compliance scans
  • Risk reserve for outages, breaches, or failed audits

Typical outcome

Hundreds of thousands in engineering over multi-year horizons—before you ship differentiated product work.

Deadwood trajectory

  • Integration measured in days-to-weeks
  • Operations, scaling, and resilience bundled into subscription + meters
  • Finance sees usage dashboards—not mystery invoices
  • Engineering stays on roadmap features users notice

Typical outcome

Lower multi-year spend with faster iteration—especially once traffic grows nonlinearly.

Switching costs—stated clearly

Portable artifacts reduce trap dynamics, but migration is never zero. Small footprints export quickly; large fleets require coordinated inference cutovers and verification windows. We document exports up front because trust beats lock-in theater.

What travels easily

  • Checkpoint binaries + manifests
  • Training logs + evaluation notebooks
  • Ledger receipts for finance reconciliation

What costs time

  • Rewiring inference routers inside your stack
  • Replaying governance approvals with a new vendor
  • Retuning latency budgets after CDN topology changes

Enterprise-grade security

Security is operational discipline—not a single checkbox workshop.

Encryption everywhere

TLS for every customer hop; encrypted disks for persistence; hashed secrets in our control plane.

Tenant isolation

API keys scope access; workspaces separate environments; optional private networking on enterprise contracts.

Assurance programs

SOC2 Type II posture, GDPR-aware workflows, HIPAA pathways via Autonomous paperwork—not handshake promises.

Resilience

HA databases, encrypted backups, rehearsal restores for mission-critical tenants.

Ready to add personalization?

Start free

Free tier, no credit card. Build your first model.

Get free API key

Go production

Accelerator tier. Full features. $99/mo after trial.

Start 14-day free trial

Talk to us

Custom pricing, SLAs, and support for enterprises.

Schedule demo

Questions?

Hardware-aware execution paths