Introducing Telos Cloud

Software engineering has moved through space and time over the last two years.

I still recall the rush of using Opus class models back in December 2025. It felt like a defining step change in capability. Snap your fingers, and you could build anything you wanted in no time.

You could feel it online: new side projects were being spun up faster than ever before, and there was buzz and excitement in the air.

The breakthrough wasn't simply that AI could write good code. It was that I no longer had to read it. I could work entirely out of my coding agent. All that time I spent playing around with Vim shortcuts was now replaced by a simple chat-box!

But as this capability accelerated my work, the process around it started to feel increasingly backwards. What began as a headrush was slowly turning into a hangover:

More code, more problems

For starters,

• AI chats today are imperative, step-by-step instructions. The prompts we're writing are streams of thought that get thrown away. The generated code is what we end up storing.

In traditional software engineering, you write, store, and maintain code which gets compiled down to a lower-level language that we treat as a black box. With vibe coding, we write our "intent" as prompts (that we throw away), treat generated code as a black box, but store, maintain, and iterate on the generated code. That's an inversion!

• We're feeling the tyranny of the weakest link more than ever. Generating code faster just shifts the bottleneck elsewhere: code review, pull requests, CI, and the repeated handoffs between dev, test, and prod.

We were retrofitting new technology into processes designed for a world where code was scarce and expensive. The mismatch was fatiguing: constantly reviewing AI output, prodding panes of agents on, and manually taming AI slop made the job feel like managing a bunch of fussy, impatient pets.

It became obvious that the way I was working with coding agents hadn't kept up with what they could do.

From tasks to goals

As the models improved, the unit of work expanded with them. I could describe an outcome, define what done meant, and let an agent work toward it for hours or even days.

Watching my agents tear through a terminal faster than my eyes could follow felt like a glimpse of self-driving software.

But I was still sitting there, watching every turn.

I felt pulled in opposing directions. I didn't want to read and maintain massive volumes of inscrutable AI-generated code. But I still wanted control over a living source of truth I could come back to and maintain.

Goals were emerging as a powerful workflow, but the interfaces around them still assumed I would sit there for every turn. A goal should run in the background, persist, and remain steerable.

I started to wonder: if the system became reliable enough, could the goal itself become the abstraction?

Out of that mix of wishful thinking and a growing list of grievances, I started building the system I wanted to use. We've spent the months since dogfooding it quietly. Now we're ready to share it.

Introducing Telos Cloud

Today, we're introducing Telos Cloud: a managed platform for declarative software. Give it a goal, and Telos builds, runs, verifies, and evolves the software behind it.

In Telos, that goal becomes a persistent artifact: the Goal spec (SPEC.md), a description of what your software must do and which properties should remain true as it evolves. You can parameterize your Goal with skills and rubrics to give it explicit context and hard completion conditions.

Telos gives each Goal a persistent system of agents in the cloud that works autonomously to satisfy it.

Telos Cloud takes care of the managed runtime, inference, and hosting around that system. Use our managed inference gateway, or connect an existing ChatGPT or xAI subscription.

We also want to meet you where you already work: inside your coding agent. Telos is designed to be driven entirely from there.

Let's walk through a simple example:

Take the status page from our product demo. Its contract starts as a small, concrete SPEC.md:

---
name: status-page
version: 1.1.3
platform: cloud
---

# Goal

Run a public status page for Halcyon's services.

- Incidents appear within one minute and persist.
- `GET /api/status` returns every service with its current state.
- Incident history survives restarts and redeploys.

# Acceptance

- A newly reported incident appears on the public page within 60 seconds.

Before changing anything, preview the Goal:

$ telos plan SPEC.md
Spec      status-page
Target    cloud
Path      SPEC.md
...

Once you're happy with the plan, apply it.

$ telos apply SPEC.md
created status-page

Status    working
Session   sess_c7d2f0a4e8
Revision  sha256:8f21c47a...
Logs      telos logs sess_c7d2f0a4e8

telos apply publishes the reviewed revision and gives the Goal a persistent session. The command returns immediately while Telos' agents work to build, test, and deploy the service in the background.

The same environment is dev, test, and prod. Telos builds, verifies, and runs the service in place.

Check the Goal's current state at any time with:

$ telos describe sess_c7d2f0a4e8
Name      status-page
Status    ready
Session   sess_c7d2f0a4e8
Revision  sha256:8f21c47a...
Service   https://status-page-c7d2f0a4e8.usetelos.ai

Ready means the exact revision above is running and has passed its checks and required rubrics under independent evaluation.

Or view the agent logs for more granular tracing:

$ telos logs sess_c7d2f0a4e8
[2026-08-10T12:00:00Z] [INFO] Accepted managed session
[2026-08-10T12:04:22Z] [INFO] Implemented persistent incident history — Added durable storage and restart coverage
[2026-08-10T12:08:47Z] [INFO] Service URL verified
[2026-08-10T12:11:06Z] [INFO] Running the required service checks — Reporting an incident, restarting the service, and probing /api/status
[2026-08-10T12:15:31Z] [INFO] Current revision accepted

Once it's ready, interact with the live service to see whether it meets your needs.

Forgot something in your spec? No problem.

You can update the spec and then re-plan against the durable session:

$ telos plan SPEC.md --session sess_c7d2f0a4e8
Session   sess_c7d2f0a4e8
Current   sha256:8f21c47a...
Version   1.1.3 -> 1.2.0

+ 30 days of uptime history render for each service.

After review, apply:

$ telos apply SPEC.md --session sess_c7d2f0a4e8

And just like that, Telos' agents wake up and reconcile the change. Work is incremental; the session, history, and service URL stay stable.

You don't need to watch the agents work faster than your eyes can trace them. The living Goal is what you come back to.

Putting it all together

Telos is our answer to the problems above:

• Intent gets thrown away. The Goal becomes the living source of truth that we read, review, version, and change.

• Everything after codegen becomes the bottleneck. Telos collapses dev, test, and prod into one environment, shortening the loop from intent to a running, verified result.

• How do we trust code we don't read? The Goal persists as requirements change, and an independent adversarial verifier checks the implementation against it. We wrote more about why that works here.

• Agents are fatiguing to manage. A Goal runs in the background and remains steerable. You return when you want to inspect or change it.

With those pieces in place, the Goal becomes the interface: you describe what the software should do, and Telos handles the implementation underneath.

We've seen this before. React replaced manual DOM updates with declarative UI. Terraform and Kubernetes replaced manual provisioning and pet servers with durable desired state and reconciliation. We don't want to keep pet agents any more than we wanted to keep pet servers.

Telos is our bet that AI coding can make the same jump.

A more ambitious Goal

The status page shows the interface. We wanted a more ambitious test of the system's capabilities.

The Goal: build and operate an original multiplayer browser FPS, with no accounts, playable by anyone with the link.

The result is Breachpoint, a live multiplayer browser FPS. The same Goal has persisted for more than 26 days, through nine versions.

Telos built, tested, and deployed the whole thing autonomously: the engine, netcode, maps, weapons, art, and audio. The live client alone contains more than 11,000 lines of first-party JavaScript.

Across 1,260 completed agent passes, Telos ran full browser playthroughs, two-client multiplayer tests, injected-latency tests, persistence checks, and GPU-backed visual evaluations. The service has recorded more than 3,900 matches. We'll publish a deeper technical breakdown shortly.

I still haven't read the generated code.

Play Breachpoint now →

Get started

Telos Cloud is now in open beta. Try it in the cloud, or run the harness locally (source code).

Give this to your coding agent:

Telos is early, and writing good Goals is still hard. We think it will become one of the defining skills of this new way of working, and the beta is where we begin learning that together. The complete workflow is in the docs.

Questions, bug reports, and strange Goals are welcome at [email protected].