Turn the Macs you already own into a private compute fleet.
Fleet Orchard is a drop-in Swift SDK you embed in your own macOS app. Take a unit of work, distribute it across the Apple-Silicon Macs you already own, run it, and report back. All steered from a hosted console. First-party, private, and yours.
Fan one ML job across every Mac you own.
A phone snaps a photo for inference, your Macs and servers command jobs into the queue. The coordinator hands each unit to whichever Mac is idle, runs it on the Neural Engine, and reports back. Toggle the sources and scale the fleet to watch it balance in real time.
Bring any parallel workload. It handles the fan-out.
Fleet Orchard is the distribution layer, not the workload. You bring the model, the agent, or the encoder; it spreads the work across the Macs you own and collects the results. Where teams point it:
ML inference & batch
Replaces cloud GPU inferenceYou already run Core ML and Vision on-device. Hand the batches (segmentation, embeddings, transcription) to the fleet and every Neural Engine works a share.
Agent fleets
Replaces metered agent sandboxesYour agent is the worker. Register it once and the coordinator spreads long-horizon runs across Macs you control, claiming the next free one instead of a metered cloud VM.
Media encode & render
Replaces the render farmWrap your encoder or renderer as a handler. The fleet splits the job by segment, and VideoToolbox on each Mac does the heavy lifting.
Also: CI and device-test matrices, data preprocessing, distributed fuzzing.
Three moving parts. One of them is the app you already ship.
You already ship one of them. Fleet Orchard is the other two: an app on each Mac, and a hosted control plane.
Your app + our SDK
Add Fleet Orchard with Swift Package Manager and register your work handlers. They compile into your binary, so the worker is just your app running on a Mac. Only data-only descriptors cross the wire.
The Fleet Orchard app
The on-device connector. It registers your app, claims work as each Mac frees up, runs it locally, and orchestrates updates from your own source.
Coordinator & console
A durable work queue and a console to steer it. Enqueue work, watch nodes come online, track throughput, and retry failures from one place.
Ship an update. It lands on every Mac.
The Fleet Orchard app runs on each Mac and keeps your connected apps current. Push a new build and it pulls from your own source (a Sparkle appcast, GitHub main, a CI artifact) and rolls the fleet forward. It orchestrates the update. It never moves your code.
Pulls, never pushes code
The build comes from your own Developer-ID source, not our servers. Fleet triggers the rollout; your signed code stays yours.
One version across the fleet
Pin a release and every node converges on it. Roll the fleet forward, or hold it back, from the console.
The link to the coordinator
Each connected app registers through it, claims work, and reports its health. One connection per Mac, straight to the coordinator.
Built in the open. Yours to build on.
The Swift SDK and the Fleet Orchard app are MIT on GitHub. Clone them, extend them, wire in your own handlers, and ship them inside your own products. We keep the lights on with the hosted coordinator and console: the durable queue, the retries, and the fleet-wide observability a serious workload needs.
Yours to build on
The SDK's worker runtime, handler registration, and work-descriptor protocol, plus the on-device connector. Fork it, extend it, or vendor it straight into your own app.
Browse the source on GitHubWe run this part
The durable queue, node registry, retries, access control, and one console over the whole fleet. State and coordination that survive a laptop closing its lid.
You own the Macs. We run the queue.
Everything on your hardware is open source and yours. You pay only for the hosted coordinator and console. Here is what that costs.
Start free. 100 completed tasks a month, on us. Enough to wire up your fleet and prove out a workload.
Scale on usage. A $20 monthly minimum that your usage draws down. Tasks meter from $0.001 and drop as you scale, so you pay more only once usage passes $20. Bring your own storage, plus fleet-wide observability, retries, and priority support.
Or run it yourself. Run the coordinator in your own infrastructure, priced by node band with a one-time setup and billed by invoice. Same open code, your servers. Talk to us for SSO, audit logging, and an SLA.
In early access. Join the waitlist for an invite.
A handler and three calls.
Add the package, write a Sendable handler for your task type, then register,
consent, and start. Handlers run off the main actor, and only data work-descriptors cross the
wire. The producer side is one call too: submit, then awaitCompletion.
import FleetCore
import FleetTransportCoordinator
// A handler is Sendable, runs off the main actor, and returns data.
struct ResizeHandler: FleetTaskHandler {
func run(task: FleetTask,
onProgress: @Sendable (Double, String) -> Void) async -> FleetTaskResult {
guard case let .string(name)? = task.parameters["dataset"] else {
return .failure(reason: "missing dataset")
}
onProgress(0.5, "resizing \(name)")
return .success(resultPayload: ["ok": .bool(true)])
}
}
// Enroll this Mac, register the handler, start the loop.
let fleet = Fleet(configuration: .coordinator(baseURL: coordinator, identity: identity))
await fleet.register(ResizeHandler(), for: "resize")
await fleet.setConsent(.granted(scope: .all)) // never claims until granted
await fleet.start() // claim → run → heartbeat → reportPut the Macs you own to work.
Fleet Orchard is in early access. Leave your email and we'll send an invite when the coordinator opens up.
No spam. One email when it's your turn.