# Co/Core: An AI Cooperative

> Source: <https://console.cocore.dev/>
> Published: 2026-06-18 20:18:09+00:00

# 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](/agent/app)

## 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](https://huggingface.co/models?library=mlx).

``` python
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,
)
python
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.