Calyraen Labs

Where the next thing starts.

Labs is where we build in the open. Early experiments, public betas, and the tools and APIs that power Calyraen, shared while they are still being figured out.

Talk to us

Most of what we ship started here. Out loud, in public, before it was finished.

An idea does not get better in private. Labs is the part of Calyraen where we put rough work in front of real people and let it grow up faster.

What Labs is for

Three kinds of work live here, each at a different stage of becoming real.

Experiments

Small, sharp ideas we want to test. They might become a product, or they might teach us something and quietly close. Either is a success.

Public betas

Features that are real and working but not yet finished. You can use them today, tell us what breaks, and watch them get better week to week.

Open tools and APIs

The building blocks. The same APIs our own teams use, opened up so you can build on top of Calyraen instead of around it.

How we work in the open

A few habits that make Labs different from a normal product page.

Honest labels

Everything here is tagged Experiment, Beta, or Stable. You always know how finished a thing is before you depend on it.

Changelog you can read

Every change to a Labs project is written down in plain language. No silent breakage, no mystery updates.

You can leave

Export your data from any Labs project at any time. Nothing here locks you in while it is still being figured out.

We answer

Feedback goes to the people who built the thing, not a queue. The fastest way to change a beta is to tell us what is wrong with it.

Have a look inside.

See the experiments running now, the betas open for sign up, and the APIs you can start building against today.

Talk to us

What is inside

Three stages of an idea.

An experiment becomes a beta becomes something stable. Here is what each stage looks like, and what you can do with it right now.

Experiments

The earliest stage. Rough by design. We share these to learn whether an idea is worth building at all.

Built fast, on purpose

An experiment exists to answer one question. Does this work? Do people want it? We build the smallest version that can answer it and put it in front of you.

Some will close

We tell you up front that an experiment might end. If it does, you get notice and a clean way to take your data out. A closed experiment is not a failure, it is a finished question.

You shape what survives

Which experiments graduate to betas is decided by how they are used and what you tell us. The ones people lean on get more attention. The rest teach us something and step aside.

Running now

A taste of what is on the bench

A rotating set of experiments. Names and details change as ideas come and go.

Plain language search

Ask a question in normal words across your Calyraen account and get a real answer, not a list of links. Testing how far natural language can replace menus.

Read the notes

Quiet mode

A device profile that strips notifications, animation, and background activity down to almost nothing. Built first for our own machines, now open to try.

Read the notes

Shared canvas

A live document where a whole team edits the same page at once, offline edits included. An experiment in how far we can push real time without a server in the loop.

Read the notes

Public betas

Real features you can use today. Finished enough to rely on for most things, honest about the rough edges that remain.

Working software, named edges

A beta does the job. We also keep a public list of what does not work yet, so you are never surprised by a gap we already knew about.

Changes you can follow

Each beta has a changelog written for humans. New this week, fixed this week, known to be broken. You read it in under a minute.

A clear road out

When a beta becomes stable, your settings, data, and integrations carry over. Joining a beta is never a dead end you have to back out of.

Open tools and APIs

The same building blocks our own teams use, opened up so you can build with Calyraen instead of beside it.

The real APIs

Not a watered down public copy. The Labs APIs are the endpoints our products call. When they get faster or gain a feature, so do yours.

Stable contracts

Once an API is marked stable, we do not break it without warning and a migration path. Versions live side by side so old code keeps working while you move.

Read before you build

Every endpoint has worked examples, a sandbox to try it in, and rate limits printed in the open. You know the rules before you write a line.

Use what we use. Build on the same ground we build on.

There is no second class public version. The tools in Labs are the ones running inside Calyraen right now.

For developers

Get a key. Make a call. Build something.

Labs is API first. A few minutes from sign up to your first working request, with a sandbox so nothing real moves until you are ready.

How to get access

Three steps, no sales call, free to start.

1. Create a Labs account

Sign in with your existing Calyraen account or make a new one. A Labs workspace appears with sandbox keys already generated.

2. Try it in the sandbox

The sandbox is a full copy of the API with fake data. Send real requests, see real responses, break things freely. Nothing here touches a live account.

3. Switch to live

When your code works, swap the sandbox key for a live key. Same endpoints, same shapes. The only thing that changes is that the data is now real.

Your first request

Authenticate, list what is available, and read one item. Real shapes, no surprises.

labs-quickstart.sh

$ # 1. set your sandbox key from the Labs dashboard
$ export LABS_KEY="sk_sandbox_••••••••••••"
$ 
$ # 2. check that the key works
$ curl https://api.calyraen.com/labs/v1/ping \
$   -H "Authorization: Bearer $LABS_KEY"
$ # -> { "ok": true, "env": "sandbox" }
$ 
$ # 3. list the experiments your key can reach
$ curl https://api.calyraen.com/labs/v1/projects \
$   -H "Authorization: Bearer $LABS_KEY"
$ 
$ # 4. read one project and its current stage
$ curl https://api.calyraen.com/labs/v1/projects/quiet-mode \
$   -H "Authorization: Bearer $LABS_KEY"
$ # -> { "id": "quiet-mode", "stage": "beta", "version": "0.7" }

# 1. set your sandbox key from the Labs dashboard
export LABS_KEY="sk_sandbox_••••••••••••"

# 2. check that the key works
curl https://api.calyraen.com/labs/v1/ping \
  -H "Authorization: Bearer $LABS_KEY"
# -> { "ok": true, "env": "sandbox" }

# 3. list the experiments your key can reach
curl https://api.calyraen.com/labs/v1/projects \
  -H "Authorization: Bearer $LABS_KEY"

# 4. read one project and its current stage
curl https://api.calyraen.com/labs/v1/projects/quiet-mode \
  -H "Authorization: Bearer $LABS_KEY"
# -> { "id": "quiet-mode", "stage": "beta", "version": "0.7" }

What you can count on

The rules of the road, written down so you are not guessing.

Versioned endpoints

Every API carries a version in its path. We add to versions, we do not change them underneath you. A new version ships beside the old one, never on top of it.

Rate limits in the open

Your current limit and how much of it is left come back in the response headers of every call. No hidden ceilings, no surprise throttling.

Webhooks and keys you control

Create and revoke keys yourself. Point webhooks where you want, with signed payloads so you can prove a message really came from us.

Sandbox that mirrors live

The sandbox runs the same code as production with isolated fake data. If it works in the sandbox, it works live.

At a glance

The numbers and limits for a free Labs developer account.

Access

Sign up: Free, self serve, no card
Sandbox keys: Unlimited
Live keys: 5 per workspace
Environments: Sandbox and live, fully separated

Limits on the free tier

Requests: 10,000 per day
Rate: 60 per minute
Webhook endpoints: 3
Data retention: 30 days of logs

Support and docs

Reference docs: Every endpoint, with examples
Changelog: Public, per project
Feedback: Straight to the build team
Status: Live uptime for every API

If it works in the sandbox, it works in production.

Same endpoints, same shapes, same code. The only thing that changes when you go live is that the data is real.

Ready to build?

Create a free Labs account, grab a sandbox key, and make your first call in the next few minutes.

Talk to us

Pricing

Mostly free. On purpose.

Labs is where ideas grow, so the door is open. Experiment, build, and ship against the free tier. When you outgrow it, we will sort out the rest together.

Two ways to start

Free covers most builders. When you need more room, we talk.

Labs Free

0 forever

Unlimited sandbox keys
5 live keys per workspace
10,000 API requests per day
60 requests per minute
3 webhook endpoints
30 days of logs
Full reference docs and changelog
Feedback straight to the build team

Create a free account

Labs Scale

Let's talk

Higher request and rate limits
More live keys and workspaces
Longer log and data retention
Priority on beta access and roadmap
A named contact on our team
Custom terms for production workloads

Talk to us

What free really means here

No tricks. A few things worth saying out loud.

No card to start

Sign up, get keys, build. We never ask for payment details to use the free tier, and we will not quietly start charging you.

Free is not a trial

The free tier does not expire. If it fits what you are building, you can stay on it as long as you like.

You only move up when you need to

Scale exists for real production load. Until you hit the free limits, there is nothing to buy and no reason to upgrade.

Questions before you start

It can. Experiments are labelled as experiments precisely so you know they might close. If one does, you get notice well ahead of time and a clean way to export anything you have stored. Stable APIs do not work this way; once an API is marked stable we keep it running and warn you long before any change.

Requests above the limit are slowed rather than cut off, and your dashboard tells you clearly that you are near the ceiling. That is the signal to talk to us about Scale. Nothing breaks and nothing gets billed without you agreeing to it first.

Yes, that is what they are for. Stable APIs are production ready and carry version guarantees. Just build on the endpoints marked stable rather than the experimental ones, and move to Scale when your traffic outgrows the free tier.

There is no public price sheet because Scale is shaped around your workload. You tell us what you are building and how much room you need, and we put together terms that fit. Reach out and we will take it from there.

Start free. Grow when you are ready.

Create a Labs account today and build against the free tier. When your idea outgrows it, we will be here to scale it with you.

Talk to us