An AI cooperative.
co/core is a place where people share the compute they already own to run AI for each other, instead of renting from a handful of giant providers. It's an experiment in inference we build, share, and own together — and your existing code works as-is, because we speak the same standard API everything else does. The models are open ones that run on the hardware people already have.
↓Have compute to share? Get the cocore app — macOS, Apple Silicon
Real members. Real machines. Real receipts.
A glimpse of the co-op right now — some of the people who've signed up, some of the machines sharing compute, and the latest jobs they've signed off on. Every one of these is a real, public record.
Just change three lines.
Cocore speaks the same API language as everybody else. Point your existing SDK at console.cocore.dev/v1, drop in a cocore-… key, and keep going — streaming, tool calls, and the usual chat/completions shape all work, no code changes. Host from our presets or any MLX model.
from openai import OpenAI client = OpenAI( base_url="https://api.openai.com/v1", api_key="sk-proj-…", ) resp = client.chat.completions.create( model="gpt-4o-mini", messages=[{"role": "user", "content": "hello"}], stream=True, )
from openai import OpenAI client = OpenAI( base_url="https://console.cocore.dev/v1", api_key="cocore-7f3a2c…", ) resp = client.chat.completions.create( model="mlx-community/Qwen2.5-0.5B", messages=[{"role": "user", "content": "hello"}], stream=True, )
You send a request. The co-op runs it.
Your request finds a member's available compute, runs the job, and comes back to you. The whole thing is an open spec — every job leaves a signed, public record anyone can verify for themselves, ours included.
You send a job
Your encrypted prompt heads out into the co-op. Run your prompt for a given model anywhere in the open network, or choose to keep your jobs private to only a trusted circle of co-op friends and their machines.
A member runs it
Someone picks up your job, runs it, then returns the result after signing with a key locked in the Secure Enclave that never leaves their hardware — proof of exactly who did the work, and that nobody touched it after.
Receipts, in the open
A receipt closes out the job — credits go to whomever who ran it, minus a small cut to a shared pot. Each month that pot splits back to members by how much they pitched in, so the cut cycles right back to the people running the network.
You don't have to take our word for it.
Every job writes a receipt anyone can verify on their own, without ever calling us. We can't inflate a balance, fake a payout, or quietly change the rules. And if you don't like how we run things, you can run the whole thing yourself — point your own copy at the same data and it lands on exactly the same numbers.
Here's a real receipt and the records it points back to — the job you sent, the machine's attestation, and the public settlement. Follow the chain and check it yourself.
An open standard. Run your own exchange.
Underneath the co-op is an open standard for two plain things: making an inference request, and recording what happened afterward — a signed, public account of every job. We run one exchange on top of it, with our rules: one unit in, one unit out, a shared pot that goes back to members. But the standard is the real work here. Anyone can stand up a different exchange — their own pricing, their own membership, their own idea of what's fair — reading and writing the very same records. Ours is just the first one. If co/core ever stops being the version you want, you don't have to ask us to change it; you can go build yours.
Share your compute. Help run the co-op.
Download the cocore app, sign in, pick a model or two, and your computer joins the network — running jobs for other members while you're not using it. No Terminal, nothing to babysit; it updates itself. Every job it runs adds to your balance, and a share of everything the co-op does comes back to members each month.