One API for the models your machines already run
Use every model your team already runs, from anywhere.
Reach the models your home and office machines already run from any coding agent or script, wherever you are working. No stranded GPUs and no endpoint to babysit. Add people you trust when you want more capacity.
Public beta. You don't need a GPU to join, and nothing to install to try it.
POST /v1/chat/completions model qwen3-35b
The answer, and the machine that produced it, appear here.
Point a coding agent at the workstation at the office, from your laptop somewhere else.
Send an eval or classification batch across the idle GPU boxes your team already owns.
Reach your own models while travelling, without exposing any of them to the internet.
One list of models, every machine you have
Every model your group's machines run shows up as one list any member can call. Your laptop can use a model running on the workstation upstairs. Each request is served end to end by a single machine.
Machines join without opening a port
A machine joins over a connection it opens outward. No public inbound port, no static address, no VPN. What you govern instead is who is in the group.
Your own work comes first
Send work to a machine you share with your group and it comes first. If someone you invited is already using it, their request yields: it moves to another available machine in the pool when nothing has come back to them yet, and otherwise ends at the last part they received.
Without Saylek
- A separate endpoint per machine, and a VPN or port forward to reach any of them
- Tools reconfigured for whichever runtime happens to be serving
- Idle cards at home while a metered bill grows at work
With Saylek
- One endpoint and one credential, from anywhere
- One list of models, whatever machine is serving them
- Work lands on hardware your group already owns
It works at two sizes
Start with your own machines. Add people when you want to.
Just you
One group, only your own machines. Reach the models each of them runs from anywhere, and point a coding agent or a document batch at hardware you already own before reaching for a metered API.
In a group of only your own machines, only your account can route work to them, and no one else's machines are in reach. Requests still travel through Saylek's relay to get there, and it keeps none of the content. See what the relay can access.
You and people you trust
Invite others and draw on what their machines run when yours is busy, or when you're away from it entirely.
This group you build by invite is your Circle. You admit each member yourself, and your work only ever runs on machines run by people you let in. Known operators, never an anonymous vendor.
Who it's for
Built for people whose hardware is already sitting there.
A team with GPUs it already bought
Give everyone one endpoint onto the cards already under the desks. Eval runs, batch classification and coding agents draw on hardware the company owns instead of adding to an external API bill, with no cluster to administer and no workstation quietly hijacked.
A lab or collective nobody administers
Six to twenty machines owned by different people, shared without a scheduler and without anyone volunteering to run one. Each owner keeps their own machine and decides who is in the group.
Anyone a metered provider does not reach
For some members the alternative is not an expensive bill, it is no service at all, because the provider does not operate in their country or cannot take their currency. A capable machine belonging to someone they trust is the access itself.
If none of those is you, it is worth reading what Saylek does not do before you sign up.
How it works
Four steps, and you can stop after the first.
Create an account and send a request
You get a Circle of your own plus a starting allowance on our demo machines, so you can call a model before you install anything or own any hardware. The allowance is capped, and it is there to prove the endpoint rather than to run on.
Point your tools at the endpoint
Change a base URL and a credential. Your existing client library keeps working.
Add a machine, if you have one
One binary. It finds the runtimes and model files you already have and serves on top of them, over a connection it opens outward.
Invite the people you trust
The machines they contribute join the pool yours draws on. You admit each person yourself, and once your group has capacity of its own the starting allowance stops being what you run on.
Connect
Change a base URL.
OpenAI Chat Completions and Responses, plus the Anthropic Messages shape common coding agents speak, all with real streaming. Many integrations change an endpoint and a credential rather than any code. Tool-calling is the one part that varies by dialect, so test it before you count on a no-code switch.
Already running Ollama, LM Studio, llama.cpp or vLLM? Saylek finds them and serves on top. It doesn't replace what you have, and it redistributes no model weights.
client = OpenAI(
base_url="https://api.saylek.com/v1",
api_key="sk-saylek-…",
)What runs on it
The models your own machines serve, reachable from wherever you are working.
Coding assistants
Point your agent at the endpoint and it runs against the models your machines already serve.
Document batches
Summarize, classify or extract across a folder, at whatever volume your own hardware sustains.
Transcription
Already running a speech engine like Whisper? A machine can front it, and transcription requests route there.
Contribute
Add a machine without opening a port.
A machine joins the pool over a connection it opens outward. No public inbound port, no static address, no VPN. Saylek listens only on the machine's own loopback interface by default, so nothing outside it can open a connection in unless you change that.
And your own work still comes first. When you send work to a machine you share with your group, it comes first; if someone you invited is using it, their request moves to another available machine in the pool. If its answer had already started arriving, it ends cleanly at the last signed point rather than hanging.
This is a membership boundary, not an isolation boundary. It governs who can reach your machine, not what a request can observe once it runs there.
inbound none listens 127.0.0.1 only uplink outbound, machine-initiated routing gated on membership on miss fails closed
Alternatives
How Saylek compares.
Each of these is better than Saylek at something, and it is worth being plain about what. What none of them packages is the thing Saylek is: one endpoint onto machines your group already owns, shared with the people you invite, over a connection that works from a home network.
| Alternative | Better at | What Saylek does instead |
|---|---|---|
Local runtime Ollama, LM Studio | Simpler for one machine, equal dialect coverage, and you can network it yourself. | Sharing capacity across several machines, deciding who is in the group, and routing between them come packaged, instead of wired up by hand. |
Gateway LiteLLM, Portkey | More mature routing, policy, observability and integrations. | Machines join by reaching outward and stay reachable only to the group you invite, instead of endpoints you wire up by hand and can already reach. |
Aggregator OpenRouter | Far more models, instant availability, real routing metadata. | Capacity is machines your own group owns and admitted, rather than vendors behind a routing layer. |
GPU rental Vast.ai, RunPod | Elastic capacity on demand, no hardware needed. | Hardware the group already owns, shared outward, with social rather than financial reciprocity. |
Limits
What Saylek does not do.
We would rather you know these upfront. If one of them matters to you, another tool is the better answer.
- Availability follows your own machines. Capacity is the machines in your group, so a request can fail when they are all offline and nothing takes over. Reaching them from outside your network also depends on Saylek staying up, which is on us rather than on your hardware. There is no hosted fallback, so reach for a managed API when something has to land no matter what.
- Open-weight models, improving fast. The ceiling is today's open-weight models on hardware people own, not the largest closed ones. That gap narrows with every strong release, and you can always point at the best model your machines can run.
- You decide who is in the group. You choose who can reach your machines, so keep the group to people you trust and as small as you like. That controls who can send work to a machine, not how work is kept apart once it runs on someone else's. If your work must stay on hardware only you control, make a group of only your own machines.
- Inference today, not training or containers. Machines answer inference requests. Training, fine-tuning, containers or logging into the box are a different kind of workload we have not opened up, at least not yet.
- Best with a capable machine in the group. The value is hardware your group already owns, so a group where nobody has a capable GPU has little to pool. The starting allowance on our demo machines covers your first requests while you get there, but it is capped rather than a supply you can settle on.
Does contributing slow down my own machine?
Your own work comes first, and you do not have to ask for the machine back. When you send work to a machine you share with your group, a request from someone you invited yields to yours. If nothing has come back to them yet, their request moves to another available machine in the pool. If their answer had already started arriving, it stops at the last part they received and they ask again. You can also cap concurrency and a daily budget per server, and pause contribution whenever you want.
Do I need an invitation to sign up?
No. Anyone can create an account, and it opens straight away. An invitation grows a group you are already in, it is not the door.
What does it cost?
There is no billing in Saylek and no transaction fees between members, so there is nothing to buy. That is a design decision, not a promotion: the capacity is hardware your own group already owns, so there is no meter to run and no payout to make. Contributing earns nothing and drawing costs nothing. There is nothing to switch on and nothing to cancel, and right now we have room to host everyone who joins.
Why would anyone share a machine they paid for?
For the same reason the group exists: the people in it cover each other. You contribute a machine your peers can use while it is idle, and you draw on theirs when yours is busy or you are away from it. Your own work takes priority on your own machine, you cap how much you contribute, and you pause whenever you want. A group of only your own machines works the same way and shares with nobody.
How do I remove it?
saylek uninstall stops the daemon, removes the service registration and deletes the binary. The machine works exactly as it did before. It deliberately keeps your config, keys, models and records. saylek wipe erases those, and a separate step removes the machine from the network.
Get started
Prove the endpoint first. Add hardware later.
Create an account and send a real request to one of our demo machines on a starting allowance. No GPU, no install and no invitation needed. We email you a one-tap sign-in link, the same link the sign-in door uses. There is room for new members right now.
Saylek is in public beta, built by a two person team.
Sizing it up first? Evaluate Saylek without an account: architecture and trust boundaries, the API surface, and what does not work yet.
Already in? Sign in.