For engineers who live in a large codebase
Your codebase, warm all week, on a fleet of your own.
Per-token APIs forget your code after a few minutes and bill you to read it again. A SparkPipe fleet serves only you, keeps what it computed about your codebase from turn to turn and week to week, and works on it overnight when you tell it to. One flat price a week, in Korea, with nothing sent to any other AI service.
Sending a few prompts a day? A $20 plan serves you better. SparkPipe is for engineers who work all day with coding agents, and for teams with their own model. For companies, professionals and independent developers, not household consumers. Try every step without money in the sandbox.
| Moment | Per-token API | Your fleet |
|---|---|---|
| 09:00 first turn | Cold: the whole context billed and prefilled again | Warm: your Functions refreshed it overnight |
| 10:45 after a meeting | Cache expired after 5 minutes: billed again | Warm: first token in 0.3–5 s |
| 13:30 after lunch | Cold again | Still warm |
| 14:10 other branch | A new prefix: another cache write | Prefilled ahead |
| 16:00 rewrite a file | The provider's speed, per output token | 126 tok/s, identical output |
| 19:00 go home | Nothing kept | Review, tests and a draft model run, if you start them |
01 Why
Your time, not tokens
Per-token APIs bill you for your codebase again and again.
The API cache is built for short sessions. On Claude it lasts 5 minutes by default; a 1-hour cache costs twice the input price to write, and a 5-minute write costs 1.25 times. Kimi's default is also 5 minutes. So every break, meeting, branch switch and subagent pays for the whole context again, and waits while it prefills. That is why a $20–50 top-up runs out so fast in agentic work, and why subscription limits arrive before lunch.
| Moment in the day | Per-token API | Your fleet |
|---|---|---|
| Next turn, within minutes | A cache read, billed per token | Warm. First token in 0.3–5 s at 137,700 tokens, measured, with no per-token charge |
| After a break or a meeting | Cache expired: the whole context is billed and prefilled again | Still warm. The cache stays for as long as you hold the fleet |
| Switching branch or module | A new prefix: another cache write, another cold wait | Prefilled ahead, overnight and between your turns |
| First turn in the morning | Everything cold | Warm. Your Functions refreshed the cache for yesterday's commits |
| Rewriting a whole file | The provider's speed; faster tiers cost more | 126 tok/s on Kimi K3 with speculation, identical output, measured and included |
| Price | Every re-read and re-write, or a subscription with quota walls | 144 HC a week: $2,160, about $12.86 an hour around the clock |
For you, the bill is the smaller cost. A wait of a minute or more sends you to another window, and getting back into the problem costs more than the wait. On your own fleet the context is computed once, and every turn after that starts from where the last one stopped.
Cache rules from Anthropic and Kimi, checked on 1 November 2026. Our own figures are measured on Fleet 1. The Customer Zero report, our own weeks of work on a fleet beside the same work on a per-token API, is published at launch.
02 Your fleet
What stays
A fleet that serves only you and remembers your code.
Pinned to you
The whole fleet serves only your requests: no shared queue, no shared cache, no rate limit but the fleet's own speed. Nobody else can book its hours while you keep booking the next week. Hold more fleets for more work: one for the day, one for the night, one for a parallel review. And when a job needs a burst, book idle fleets by the hour with the same HC.
Working state that stays
8 TB of cache on the fleet, 1 TB per node mirrored to its pair partner. Requests reuse the longest cached prefix automatically, with no slots to manage. It is deleted when another customer's booking of the fleet starts, or 24 hours after your last hour. No copies off the fleet, no backups. Treat it as working space, not an archive: if a failure ever takes both copies, we credit 24 hours of the fleet while the cache rebuilds.
Your storage
4 TB on every fleet for your repository, datasets, adapters and models, 500 GB per node mirrored like the cache. Pull models, datasets and repositories straight onto it from Hugging Face, S3 or any HTTPS URL: start a terabyte download from your laptop on a plane, and the fleet does the rest. Export it and restore it to any fleet you hold, and back up daily anything you want to keep.
Your tools
Claude Code, Codex and OpenCode, the agents senior engineers use most, each set up with one command and tested on every release. Any other tool that speaks the Anthropic or OpenAI APIs works too, and the sparkpipe CLI does everything your account does.
19 open models
Kimi K3, GLM 5.3, DeepSeek V4.1 Flash and Korea's K-EXAONE 2.0, A.X K2, Solar Open 2 and Motif 3, among others, each under its publisher's license. Several stay loaded at once when they fit in the fleet's memory, and loading another takes 20 to 80 seconds. The Fleet List has every model's measured speeds.
Only in Korea
Requests and data are processed only on machines we operate in Korea, and never sent to another AI service. Korea holds an EU adequacy decision and a UK one, so personal data from Europe can come to your fleet without separate transfer contracts. You contract with a Korean company under Korean law.
03 Functions
Work on your code
Your fleet works on your code when you tell it to.
A Function is software we build and run on a fleet you hold. Start one, or schedule it, from your account, the API or the CLI. It does its own setup: the first one you run ingests your repository. Results land in your storage and your morning report, and what a Function produces is yours. We keep adding Functions.
Your state
- Fetch
- Downloads models, datasets and repositories from Hugging Face, S3 or HTTPS straight into your storage across the fleet's nodes, checks every file, and can pack a model when it lands. Your token stays on your machine: it comes with each download, and the fleet holds it only while that download runs.
- Ingest a repository
- Takes your pushes as a git remote, with no token for your git host, and maps files, symbols and history.
- Build and refresh the cache
- Prefills the parts that change least first; after each push it recomputes only what changed.
- Prefill ahead
- Keeps the branches and modules you name warm, and prefills the likely next ones between your turns.
- Resume sessions
- Keeps yesterday's agent sessions warm, so you pick up where they stopped.
- Export and restore
- Takes your storage, cache snapshots, draft model and adapters to any fleet you hold.
- Daily backup
- One scheduled command on your own machine pulls the day's changes to your disk or bucket, with your own credentials.
Find problems
- Review the day's changes
- Reviews each change against the whole codebase, not just the diff, and confirms each finding with a test.
- Second opinions
- Runs the same review with other models and marks where they agree.
- Security audit
- Memory safety, concurrency, injection, secrets and dependencies, ranked, with reproductions.
- Tests and fuzzing
- Writes and runs unit tests and fuzzers for changed code, and reports any crash.
Do the work
- Overnight agent
- Works through a list of tasks and leaves a branch per task, with its test results.
- Codebase-wide change
- A rename, an API migration or a port, file by file, as one built and tested branch.
- Ask the whole codebase
- Runs one question or instruction over every file or module and collects the answers.
- Keep docs current
- Architecture notes, API docs and a map of the code, updated with each push.
- Morning report
- Everything the night produced, on one page and in one API call.
Models
- Train a draft model
- Trains on your repo and your sessions, so speculation accepts more of the model's tokens on your new code, week by week.
- Evaluate models on your code
- Runs your tests or eval set against every offered model and your own, to pick the best one per task.
- Qualify your model
- Checks your own model and driver against your reference outputs.
- Train an adapter
- Trains an adapter for an offered model or your own on your data.
- Make training data
- Generates training data for your own model, where each source model's license allows it.
Functions that build or run your code do it in a sandbox on your fleet, with no network unless you allow it. When a fleet changes hands we restore it to our own image, so nothing one customer ran can reach the next.
04 Your model
Private model list
Trained your own model? Serve it on your own fleet.
Upload
Send your weights to your storage with the CLI or the API. Any model that fits the fleet's memory works; Kimi K3's 1.56 TB fits.
Add a driver
We publish the model-family interface and a guide written for coding agents, so your agent can write the driver. Most new models reuse a family schedule that already exists.
Check it
A Function runs your model against your reference outputs on your fleet and reports whether they match: the same qualification our own models pass.
Use it
It appears in your model list only, next to the offered models, behind the same endpoint, and works with every Function.
05 How it works
Four steps
Demo hour, then a fleet of your own.
Open an account
Your company's legal name or your own, a work email confirmed with a 6-digit code, and the Customer Agreement. No password. Then buy HC in any quantity.
Book a demo hour
The whole demo fleet by the hour, up to 7 days ahead, 1 HC an hour. Point your own tools at it and try your codebase.
Pin a fleet
Book a first week on an available fleet, from the next Monday. When every fleet is held, join the waitlist by locking at least 144 HC.
Keep it
Book the next week before 00:00 on the Sunday of your last booked week and the fleet stays yours. The more weeks you hold ahead, the bigger the discount on every week you book, up to 20%.
Need more than one fleet for a while? Any fleet nobody holds can be booked by the hour with the same HC, up to the end of the current week, and your requests go to it like to your own. The waitlist goes biggest lock first, then earliest. Fleets are allocated every Sunday at 00:00 KST, and your whole lock books as many weeks as it pays for. You see your own position and how many are waiting, nothing more. If you stop booking, the fleet goes to the waitlist that Sunday, and your cache and storage are deleted when the next customer starts.
Weeks run Monday 00:00 to Sunday 24:00 KST, and Sunday is the free day. Eight fleets at launch.
06 Prices
One currency
Seven days for the price of six.
Everything is paid in hour-credits (HC). Buy them in any quantity, and spend them on demo hours and weeks of your own fleet. No per-token charges, and no extra charge for Functions.
| Item | Price |
|---|---|
| Hour-credits | $20 (₩26,000) each below 144 HC, $15 (₩19,500) each from 144 HC. No maximum. Each purchase lasts 12 months unless you book with it, and HC spent on a booking never lapses |
| Demo hour | 1 HC for the whole demo fleet for an hour |
| Idle fleets | Any fleet nobody holds, by the hour, 1 HC an hour times its Rate, up to the end of the current week: a burst for a big refactor, a parallel review or an overnight batch, on top of your own fleet |
| Week | 144 HC for seven days on a fleet pinned to you: $2,160 at the $15 HC price, about $12.86 an hour |
| Weeks ahead | 5% off each new week when you hold 4 or more weeks, 10% from 13, 15% from 26 and 20% at 52, counting the current week and the weeks you are booking |
| How far ahead | Up to 52 weeks |
| Downtime | A booked hour with more than 15 minutes of downtime comes back as HC, automatically, from our own records. Maintenance takes up to 3 hours a fleet a week and is credited the same way |
| Payment | In won by card (Korean or overseas), bank transfer, virtual account or Korean easy pay through Toss Payments; in USDC or USDT through CoinPayments; or in US dollars by bank transfer (SWIFT) from your own account outside Korea. Korean businesses get a card slip or an electronic tax invoice |
| VAT | 10% is added. A US dollar bank transfer (SWIFT) carries 0% when you have no place of business in Korea |
| Refunds | None, unless we stop offering service for HC or close your account through no fault of yours. HC locked in the waitlist that would lapse while you wait is refunded |
Prices are set on this website and may change; HC you have bought and weeks you have booked keep their price. The SparkPipe Customer Agreement governs, and its Korean text prevails. HYOR AI Tech Ltd. is the seller.
07 Setup
Your own tools
Point your coding agent at your fleet.
Create an API key in your account and set it in your tools. Requests go to the fleet you hold at that moment, and the fleet loads the model you name if it is not already loaded.
# Claude Code export ANTHROPIC_BASE_URL=https://sparkpipe.ai/pay/api export ANTHROPIC_AUTH_TOKEN=your key from your account export ANTHROPIC_MODEL=kimi-k3 export CLAUDE_CODE_MAX_CONTEXT_TOKENS=1000000 # Codex: ~/.codex/config.toml model = "kimi-k3" model_provider = "sparkpipe" [model_providers.sparkpipe] name = "SparkPipe" base_url = "https://sparkpipe.ai/pay/api/v1" env_key = "SPARKPIPE_API_KEY" wire_api = "responses" # OpenCode: opencode.json { "provider": { "sparkpipe": { "npm": "@ai-sdk/anthropic", "options": { "baseURL": "https://sparkpipe.ai/pay/api/v1", "apiKey": "{env:SPARKPIPE_API_KEY}" }, "models": { "kimi-k3": { "limit": { "context": 1000000, "output": 32768 } } } } }, "model": "sparkpipe/kimi-k3", "share": "disabled" } # Any other tool that speaks the OpenAI API export OPENAI_BASE_URL=https://sparkpipe.ai/pay/api/v1 export OPENAI_API_KEY=your key from your account curl $OPENAI_BASE_URL/chat/completions \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{"model": "kimi-k3", "messages": [{"role": "user", "content": "Hello"}]}'
Holding more than one fleet? Name one with "sparkpipe": {"fleet": "F3"}. sparkpipe setup claude-code, setup codex and setup opencode write these settings for you, with the SparkPipe plugin that adds the fleet's code search, test runs on its sandbox, status and morning report to the agent. Each new release of the three is tested against the fleet before we recommend it. The sparkpipe CLI also books, uploads, starts Functions and fetches the morning report from your terminal.
08 Speed
Measured
Fast where a warm fleet matters.
Kimi K3 rewriting whole files with speculation; 15 tok/s without it. The output is the model's own.
to the first token of a follow-up turn whose conversation is cached, on Kimi K3 up to 137,700 tokens. From cold: 299 s.
to prefill a 1M-token Kimi K3 prompt from cold on one fleet. On your own fleet you pay that once, not after every pause.
For brand-new code, Kimi K3 decodes at 16.2 tok/s for one request today; a draft model trained on your own code is how a fleet gets faster on it. All figures are measured on Fleet 1; methods and receipts are in PERFORMANCE_STATUS.md.
09 Technology
Source available
Sixteen small boxes, one frontier model.
Decoding a large model is limited by how fast its weights can be read. SparkPipe splits every weight and every cache entry across the sixteen nodes of a fleet, so each reads only its own sixteenth, then merges the partial results over a 100 Gb/s RDMA mesh in 16 to 38 microseconds. The engine is written from scratch in C and CUDA, and its source is public under the Functional Source License with an added permission: use it for anything, commercially too, except renting out fleets or selling inference that runs on them. Each version becomes Apache 2.0 two years after we release it.
Source: github.com/sparkpipe/sparkpipe.
10 Company
Documents