Kybernetes OS Start a pilot

Κυβερνήτης · the one who steers

Put AI agents to work. Keep the helm.

Kybernetes OS is an agentic operating system installed on a server or cloud account your company controls. Your people hand it goals. Agents plan the work, carry it out in isolated sandboxes, prove the result and wait for a person wherever money, production or customers are involved.

Installed
On your server or in your cloud account, run by us, owned by you
Models
Open models on GPUs you choose, or frontier labs with your own keys
Price
One flat monthly fee for an allowance, from $150. No meter and no overage bill
Record
Every action in a tamper-evident audit log, streamed to your SIEM

The film

Kybernetes OS in one minute

Where your data goes today, what changes when the agents run inside your perimeter, and who stays in charge.

EnglishSound on58 seconds

The console

It works like a computer, not another web app.

Kybernetes OS opens as a desktop your people already know how to use. Every project is a folder, the agents at work sit beside them, and every board, task, map and chat opens in its own window. These are real screens from the product, with demo data.

The Kybernetes OS desktop: project folders on the left, the agents at work on the right, a project's board and one of its tasks open in windows, and the bar at the bottom.
The desktop. Every project is a folder in its own colour, with what waits for you counted on it. The agents at work sit on the right, those waiting for a person first. Boards, tasks and apps open in windows that move, size and snap.
A project's board in its window: stages from Inbox to Done, with tasks held for people and tasks agents are working on.
A project opens on its board. Every task is a card in a stage, held by a person or an agent role. Agents take ready work in; people sort, check and sign off. What waits for a person is counted at the top.
A task as an app: its sections on the left and its setup at a glance, with progress through the board, the subtasks it handed out, the person in charge and the budget used.
Every task is an app. Its goal, the conversation with its agents, the result with its evidence, its files, previews and settings, each in a section. At a glance: who decides, what it breaks into, what it may use and what it has spent.
A task's merge request reviewed in the console: the files it changed on the left, one file's diff on the right, and Approve or Request changes for the whole change.
Review the change where the work is. A task's pull request, file by file: the diff, a note on any file, then Approve or Request changes. Your notes go back to the agent, which carries on from them.
The Agentic Map as a city: each project a district, each agent a small bot in its state's colour, those waiting for a person marked with an exclamation point.
The Agentic Map. Every agent at work in every project, live: a district per project, a bot per agent. A bot with ! waits for a person; a click opens what it waits for, and you decide there.
The Brain view of the Agentic Map: the Node in the middle, the projects around it and their tasks branching out, the ones waiting for a person in amber.
The Brain. The same work as a map you zoom into: your Node in the middle, each project around it, its tasks, subtasks and steps branching out. Work under way pulses; what waits for a person glows amber.
The Chat window over a project's board, showing what the Chat read and did: a file kept in the project and a task it opened.
The Chat sets things up. Ask in plain language: it creates projects, roles, routines and tasks from what your Node already has, within the rules you set, and keeps a record of everything it read and did. It sees your setup, and your data only where you allow it.
An app's page: Hetzner Cloud set up for production, the project allowed to use it, its tools and rules, and its recent calls, one of them waiting for approval.
Every tool is an app. Set it up once for the Node, choose which projects may use it and give its tools rules. In production a change waits for a person, while reads never wait. Every call shows on the app's page.
The RunPod app's page with its lanes: each lane's model, state, GPUs, hourly rate, spend this month against its budget and when it keeps warm or stops.
Lanes live in their GPU app. RunPod, Vast.ai, Verda, Phala Cloud or your own GPU servers: each app's page lists its lanes, what each spent this month against its budget, and when it starts and stops.
The Files app: places on the left, the shared files and every project in its colour with its folders, and a project's folders on the right.
Files for every project. One window for the shared files and every project's own, folder by folder, with versions, previews and downloads. Agents read and save the same files, inside your perimeter.
The helm's menu open on the desktop: search, the apps, every project with its pin, and the signed-in person.
Everything one search away. The helm opens the apps, every project with a pin for the bar, and a search across every page of the console. Ctrl K opens it from any window.
Kybernetes OS on a phone: the project folders and the agents at work, with the bar at the bottom.
The Agentic Map on a phone: a project's district with its agents, those waiting for a person marked.
On a phone, an app. The desktop becomes the home screen and windows open one at a time, so you can answer an agent, approve a step or check the map from anywhere. On a tablet, two windows share the screen.

Projects are folders

Each team's work is a folder in its own colour. Pin the ones you use to the bar; open one and its board is there.

Every agent in sight

The desktop shows who is working and who waits for a person. The Agentic Map shows every agent at once, as a city, a brain or a list.

A window for every task

Goal, conversation, result, evidence, files and settings in one place. Keep several open side by side and move between them.

A chat that sets things up

Describe what you need. The Chat builds the projects, roles and routines from what your Node offers, and never widens what your rules allow.

All your files in one app

Shared files and every project's library, with folders, versions and previews, kept on your own infrastructure.

Desk, tablet and phone

Windows move and snap on a desk, two share a tablet, and a phone gets one at a time. Light and dark, by your device's setting.

The problem

Your data, in someone else's AI.

Client files, source code and contracts go into tools your company never approved, on servers it doesn't control, under terms nobody reviewed.

Why now

Your people already use AI. Where does the work go?

Mid-size companies sit in the gap. They carry the same confidentiality duties as large enterprises, without the budget for a private AI build. So AI gets used anyway, on personal accounts, with client material, and nobody can say what left the building.

Confidential work leaves your perimeter

Most AI assistants send prompts, files and code to the vendor's cloud. Client contracts, privilege and confidentiality duties often forbid exactly that.

Bills grow with every use

A per-seat fee plus credits, tokens or agent-hours makes AI spend hard to predict. Teams end up rationing the tool the company is paying for.

Agents without controls don't survive review

An agent that acts with nobody approving, and leaves no record of what it did, will not pass your risk team, your clients' questionnaires or your auditors.

Access to a model can disappear overnight

In June 2026 a US order cut foreign nationals off a leading lab's newest models with about 90 minutes' notice. The freeze lasted 18 days. Work built on one vendor's model stops with it.

Gartner First Take, June 2026

58%

of IT decision-makers say data-residency concerns have delayed or scaled back their AI initiatives.

Cloudian survey, Feb 2026
91%

would choose on-premises, private cloud or hybrid for AI that involves sensitive data.

Cloudian survey, Feb 2026
49%

of large US companies have defined cases where autonomous AI decisions are prohibited; 74% review costs before approving AI.

KPMG AI Pulse, Q3 2026
40%+

of agentic AI projects will be cancelled by the end of 2027, over costs, unclear value or inadequate risk controls.

Gartner, June 2025

The product

One installation. Every agent your company runs. Inside your walls.

Your Kybernetes Node is the whole platform, running on infrastructure you control. We install it, keep it updated and support it. Our hub never sees your work.

What a Node holds

Everything that touches your work runs on your Node.

People, agents, keys, models and records meet in one place you own. What reaches the outside is short, listed and visible to your owners.

Kybernetes hubLicence check-in · signed releases and apps · health heartbeats and error reports, on by default and yours to turn off · problem reports you write. No prompts, files, code or usage.
Leaves the Node
A licence check-in over HTTPS with the installation's identity and the licence it holds, which also fetches signed releases and apps.
On by default
Health heartbeats twice a day, numbers and states only, which your owners can preview; reports of the Node's own errors; a daily count of the errors agents met, never their work. Each can be turned off.
When you choose
Problem reports a person writes, with diagnostics shown before they are sent.
Never
Prompts, answers, files, code or usage figures. Your models only see what your policies allow.

How it works

Goals in. Verified work out.

An orchestrator plans each goal and hands the steps to specialist agents. Each works in a sandbox of its own, proves what it did and stops for a person where your rules say so.

From a sentence to a result

Six steps, the same for code, infrastructure, research and documents.

Work is a project with a mission and rules, not a chat window. Every agent reads the mission and rules first and follows them over anything it finds in files, tickets or web pages.

  1. 1

    Ask

    Describe the goal in plain language on the board, the task form or the Chat. Make checkout load in under two seconds on phones; done when Lighthouse scores above 90.

  2. 2

    Plan

    An orchestrator sizes the goal, does small work itself and gives larger steps to specialists, choosing a role and the best-fitting model for each.

  3. 3

    Work

    Agents use real tools in their sandboxes. When one lacks something (a site, a key, a file, a decision) it asks, and resumes when a person grants it.

  4. 4

    Prove

    Tests, coverage and Lighthouse reports are read and checked. Failures go back to the agent to fix the cause, never to weaken the check. Screenshots, videos and traces are kept.

  5. 5

    Approve

    Out of the box, payments, messages, changes to staging or production and merges into your main branch wait in Needs you; you choose what waits for each tool. Approving runs exactly what was shown, once.

  6. 6

    Deliver

    Results land where the goal said: a pull request, the project's files, a server, a connected system. Each is marked delivered with evidence, or failed with the reason.

From our reference Node

17turns
45 sof agent work
$0.33of compute

An agent took a coding task, wrote the functions and their tests, fixed its own failing test and opened a draft pull request. When someone replies to a finished task, the next turn continues on the same branch and the same pull request.

Use cases

Work your teams can hand over this quarter.

Each team works in its own projects, with its own rules, budgets and people. Items marked in final testing are built and complete their live trials before they are offered in production.

Engineering

Available

Tickets taken from the board and returned as pull requests with test results, coverage, Lighthouse scores, screenshots and Playwright traces. Review each change file by file in the console and approve it there, or send notes the agent works from. A live preview of the running app for sign-off, and your CI on GitHub, GitLab or Forgejo read before review.

Go, Rust, Java, .NET, Ruby, PHP, C/C++, Node.js and Python · Chromium, Firefox and WebKit · PostgreSQL, MariaDB and Valkey beside the agent

IT and platform

Available

Infrastructure changes planned with OpenTofu, Helm, kubectl and Ansible, then applied through your Cloudflare, Hetzner, DigitalOcean or other API keys, per environment. Servers reached over SSH with pinned host keys. Whole tasks can run on your own Linux machines.

Production commands wait for a person by default

Operations and finance

Available

Recurring work on a schedule: a weekday 09:00 report, budget variance analysis, invoice reconciliation, board updates, OKR tracking and RAID logs. Each run keeps its state and takes your corrections forward.

150 starter skills and over 100 ready-made roles, from chief of staff to finance and risk analyst

Research and writing

Available

Web research through Brave, Tavily, Exa or your own SearXNG, with every search on the record. Reports, briefs, requirements documents and runbooks saved to the project's file library, with versions.

Project memory keeps decisions and preferences, each with where it came from, confirmed only when a person or a tool's result showed it

Security and compliance

Available

Compliance evidence collected, security findings written up from notes and tool output, and lab servers checked over SSH with the engagement's credentials, given to that task and its steps and deleted when it ends.

Credentials are used through the Node and cleaned from every reply

Business tools

Available

Official MCP servers of over 40 vendors as apps, among them Atlassian (Jira and Confluence), Notion, Linear, Asana, GitHub, Stripe, Sentry, Intercom and Pipedrive, plus any MCP server you add. Each tool is off, approved or automatic, and new tools start off.

Changes made through apps are journaled, with an agent ready to put them back

Documents and translation

In final testing

Scanned PDFs and images read into structured text with tables, and translation across about 70 languages, on open models that run on your own GPU lanes. Word documents and text PDFs are already searched and previewed without any GPU.

Pages read and characters translated stay within monthly budgets you set

Images, video and voice

In final testing

Campaign images and edits, short video, narration, music and transcription on open models. Every request passes a safety layer that refuses when in doubt, every file carries signed provenance, and a voice is cloned only with the speaker's recorded consent.

Withdrawing consent stops the voice at once and deletes its samples

In every project

  • Knowledge with its sources. Agents search the project's files, memory and past results, Word, PDF and spreadsheets included, and say what they used.
  • A task list for every agent. Each part of a request is a checkbox, and a task cannot finish while a part is open.
  • Live previews. The apps and sites agents build open for your team before anything is deployed.
  • Run order. Drag a task up and it starts next; the lowest running one pauses at a checkpoint to make room.

Across departments

  • Boards that hand work on. One department's board passes a task to another's, with what each may share.
  • Shared folders. Agents publish into folders other projects read, each publish approved first if you want.
  • A merge queue. Stacked pull requests are rebased and merged once their checks pass.
  • Your people's AI subscriptions. Claude Pro and Max subscriptions can run agents in Claude Code, beside your own models.

Apps

Your tools, code hosts and GPUs, as apps.

Everything agents reach outside the Node is an app. Install it, set it up once and choose which projects may use it. Agents never see a key: they name the app and say what to do, and the Node makes the call within the app's rules. 70 apps are ready on day one.

Work tools

Official MCP servers: Atlassian (Jira and Confluence), Notion, Linear, Asana, ClickUp, Trello, Intercom, Help Scout, Pipedrive, Attio, Calendly and more, plus any MCP server you add.

Code hosts

GitHub, GitLab, Forgejo, Gitea or any Git over HTTPS. Each account is an app, with its repositories, its sign-in and rules for each branch.

Clouds and servers

Cloudflare, Hetzner Cloud, DigitalOcean, Vercel, Netlify, Render, Supabase and Neon, and your own servers over SSH, set up per environment.

Payments and messages

Stripe, PayPal, Paddle, Mercury and Brex; Twilio, Postmark, Resend and Fastmail. Out of the box, a payment or a message waits for a person.

GPUs and models

RunPod, Vast.ai, Verda and Phala Cloud, your own GPU servers, cluster or inference servers, and Anthropic, OpenAI and Google with your keys. Each GPU app runs its own lanes.

Search and insight

Brave, Tavily, Exa or your own SearXNG, Perplexity, Firecrawl and Jina AI; Sentry, PostHog, Mixpanel, Amplitude and Grafana Cloud.

Every app under your rules

  • Per tool. Each tool is off, approved by a person or automatic. A server's new tools start off, and a tool whose definition changes is turned off until a person looks.
  • Per environment. Each setup is development, staging or production. In production, changes wait for a person and reads never wait.
  • Per project. Projects attach the apps they need and can only narrow their rules.
  • Keys in the vault. Tokens, keys and certificates are sealed on the Node. Agents get the result, cleaned of every secret.

Updated on their own

  • Apart from the OS. Apps are published and updated on their own, signed for your licence.
  • New asks shown first. An update that asks for a new host, tool, looser default or secret waits for your owner with the difference listed. One that asks for nothing new can apply itself.
  • One click back. Roll back returns an app to its version before, with its settings, rules and projects kept.
  • Sandboxed code. An app's own code runs in WebAssembly, with no network and no files, only the functions it declares.

Control and governance

Agents act. People decide what matters.

The limits are enforced by the platform, not written into a prompt. A sandbox, a closed network, a vault and approval gates stand between every agent and anything it could break.

What your risk team gets

Guardrails that are on from the first day.

Out of the box, payments, messages, deployments and merges into your main branch wait for a person. You decide what waits on each app, server and repository.

Approvals where each tool is set

Each app tool is off, approved or automatic, per environment; servers wait by environment and kind; Git by repository and branch. The approver sees the exact request and approves it once; a denial reaches the agent with its reason.

What needs you, live

Each project's Needs you lists its questions, approvals, requests and tasks waiting for a person, and the Agentic Map counts every wait across projects. A daily email and browser notifications are optional.

Permissions only narrow

Work an agent creates (subtasks, new tasks, schedules) inherits its creator's limits and never exceeds them. Agents ask for capabilities; people grant them.

Keys stay in the vault

App, Git and server credentials are sealed in the Node's vault (AES-256-GCM, with a key made on your Node). The Node makes each call for the agent and cleans secrets from what comes back; a private value reaches an agent's commands only if you tick it.

A closed network by default

Sandboxes reach only the hosts a project allows, starting with trusted package registries and code hosts. Cloud metadata and private networks stay closed unless your installation opens them, and every refusal is recorded with a one-click allow.

Budgets and caps

Token budgets per project and per task; for every GPU lane, a price cap per hour and a monthly budget that stops it or alerts you; and daily caps on work agents create.

An undo journal

Every change made through an app is kept with what was read before it. Ask an agent to put it back, and the request opens as a task.

A tamper-evident audit log

Every row chained by SHA-256, a signed checkpoint every 15 minutes, verified daily, and streamed to your SIEM over syslog with TLS, Splunk HEC or HTTPS.

Your identity provider

Passkeys, or single sign-on from Entra ID, Okta, Google Workspace, Keycloak or Ping, with SCIM. Roles for Owner, Operator, Support, Finance and Viewer; Operator, Support and Viewer can be kept to chosen projects.

Models and compute

GPUs start when there's work and stop when it's done.

Open models run on GPU lanes in your own account or on your own hardware. Frontier labs join with your own keys. Each project decides which of them may see its data.

Your choice, enforced

Use the best model for each job, and keep one you control.

Every project names the places its data may be processed. The gateway checks each call against that policy and refuses anything outside it.

Where inference runsWhat it coversWho could see prompts
C0Your hardwareAn inference server you already run (vLLM, SGLang, TGI, NVIDIA NIM, Ollama), Available
GPU servers you join to the Node, or your own GPU cluster through its API, In final testing
Only your organisation
C1GPUs rented in your accountOpen models on GPU lanes in your own account at RunPod (Secure Cloud), Vast.ai (verified hosts), Verda or Phala Cloud, only in the countries you allow, encrypted end to end with TLS ending inside the machine. A project can require confidential GPUs, whose hardware your Node verifies before useThe GPU host's machines; its proxy and network carry only encrypted traffic. On confidential GPUs the hardware also encrypts memory
C3Frontier labs, your keysAnthropic, OpenAI and Google, called directly with your own keys, and Claude Code on your people's own Claude subscriptions; off until you enable themThat lab, under your own agreement with it

How lanes behave

  • In their GPU app. Each provider's app holds its lanes: RunPod, Vast.ai, Verda, Phala Cloud, your own GPU servers or your cluster. The Models page shows which lanes serve each model.
  • On demand. A lane starts when work is waiting and stops after the idle time you set, from 2 minutes to a day, or keeps warm hours on a schedule.
  • Within budget. Each lane has a price cap per hour for each replica and a monthly budget, a hard stop or alerts at 80% and 100%.
  • Best value at each start. The lane picks the GPU setup with the best price for its speed, including smaller copies of the model on newer GPUs.
  • Several models, one lane. A lane serves its model and up to seven more, chat, media or helpers. Agents name the model, not the lane: the gateway picks the least busy lane and starts one when work waits.
  • Right model for the job. Each task runs on the model you choose or your project's default; leading agents pick a model for each step, ranked across nine kinds of work, and the timeline says why.
  • Continuity. If a lab changes its terms or cuts access, move the work to an open model on your lane. Agents, memory and history stay where they are.

Open models in the catalog

DeepSeek V4.1 FlashGLM-5.3 FlashMiMo-V2.6 FlashQwen3.8-27BQwen3 EmbeddingLightOnOCREuroLLMLMT-60Qwen-ImageZ-Image TurboFLUX.2 kleinCosmos3Wan 2.2VoxCPM2ACE-Step 1.5Whisper large-v3

Fully permissive licences only (MIT, Apache 2.0, OpenMDW), with no use policies or thresholds. The catalog is signed and every model file is checked against its hash before it loads. Lanes never fetch from public model hubs.

Installation and operations

Installed by us. Owned by you.

We install, update and support the Node. When the installation is done you can remove our access, and from then on we can't act on your server until you grant access again.

Running it

A managed service that runs on your infrastructure.

A Node is single-tenant: one company, one installation. It needs an x86-64 server with Ubuntu Server 24.04 or 26.04 LTS (from 2 vCPU, 4 GB of memory and 40 GB of disk; 8 vCPU and 32 GB to run several agents at once), on your premises or in your cloud account, and a domain. Sandbox servers and GPUs join as you grow.

Installation

  • Checked before anything runs. The installer records your server's identity and stops if it changes. Every component is checked against pinned hashes and the signed release.
  • Hardened as it installs. A firewall, automatic security upgrades, brute-force protection and time sync, with each task attempt isolated in a gVisor sandbox.
  • Your domain, your certificate. The console runs on your own address, with sign-in by passkey from the first minute.
  • Our access ends when you say. The installer's account can be removed at the end, and support then works through reports your people send.

Day to day

Updates
Signed, in strict sequence, approved by your owner with a passkey, or automatic for security releases or for all, if you choose. A backup and checks run first; a failed update rolls back by itself. Apps update on their own, showing what each newly asks for, and roll back in one click.
Backups
Nightly with checksums, kept 14 days, with a weekly restore drill shown on the Status page, and copies in your own S3 bucket with Object Lock if you choose.
Monitoring
OpenTelemetry traces to your collector and Prometheus metrics, including an audit-chain gauge, once you connect them.
Offline
Keeps working without our hub for 7, 14 or 30 days, set per licence. Renewals can travel as signed files.
Your data
Delete by project and category whenever you choose, in any licence state, unless your owner has set a legal hold.

Plans and pricing

One flat monthly fee for an allowance. Every feature on every plan.

Your Node enforces the allowance itself and reports nothing about your use to us. GPU time is never counted; the GPU allowance is how much GPU memory your lanes may hold at once. There is no meter, no overage bill and no usage report to dispute. The larger the plan, the less each seat and project costs. You pay your GPU provider and any lab you connect directly; we never resell compute.

PlanSeatsProjectsGPU memory at onceMonthly, billed annuallySupport, included
Baby55300 GB1 GPU$150early bird $99 · founders and startupsEmail, best effort
Studio1510600 GB2 GPUs$616early bird $399Email, best effort
Team30151.2 TB4 GPUs$1,290onboarding $1,500, optionalEmail, within 72 hours
Business60202.4 TB8 GPUs$2,532onboarding $3,500, optionalEmail, within 72 hours, with a named contact
Enterprise100253.6 TB12 GPUs$3,999onboarding $7,500, optionalEmail, next working day
CustomRacks of GPUs, from 72 B300-class, or more seats and projects than extras suitPriced per caseA tailor-made agreement

Extras, the same price on every plan

5 more seats
$150a month
5 more projects
$75a month
300 GB more GPU memory at once
$100a month

Keep your plan and add only what you need. A GPU here is 300 GB of GPU memory held at once, about one B300-class GPU or two H200s; what your lanes hold is rounded up to the next 300 GB.

Early bird. Our first clients pay $99 a month for Baby and $399 for Studio, and keep that price for as long as they stay with us, adjusted only for inflation once a year.

Baby is for founders and startups: the whole operating system, workspace and toolset for a team of five, with 300 GB of GPU memory for open models. It needs no GPU to start. Each founder can connect their own Claude Pro or Max subscription, and the agents work on it in Claude Code, with the board, sandboxes, checks, live previews, schedules and approvals around them that Claude alone, in an editor or the Claude app, does not give you.

What the GPU allowance runs

300 GB
A coding model such as Qwen3.8-27B, with an image or video lane beside it
600 GB
A 300B-class model such as GLM-5.3 Flash, with a coding model or a media lane beside it
1.2 TB
A frontier-class open model such as DeepSeek V4.1 Flash, or GLM-5.3 Flash with coding and media lanes
2.4 TB
DeepSeek V4.1 Flash with a second replica for busy teams, plus GLM-5.3 Flash and media lanes at once
3.6 TB
Frontier-class models for every department at once: DeepSeek V4.1 Flash, GLM-5.3 Flash, MiMo-V2.6 Flash, coding and media lanes
Racks
72 B300-class GPUs and more, rented or your own, on a custom plan

The allowance counts GPU memory held at the same moment, on rented GPUs or your own. Hours are never counted, and work through your own frontier-lab keys or your people's Claude subscriptions counts against no GPU allowance.

Onboarding, add-ons and terms

Onboarding
Optional, paid once: $1,500 on Team, $3,500 on Business, $7,500 on Enterprise
Air-gapped
Delivery without internet access, $2,500 a month on Business and up

Studio and Team may also pay monthly, at 20% more. Two-year terms take 5% off and three-year terms 10%, with the price held for the term. Non-profits and education: 30% off. At a limit the Node holds back new use and says why; it never deletes anything.

Compared

What the alternatives cost, and where they run.

Published list prices. Most AI suites charge per user and add usage on top, and all of them run your work in the vendor's cloud.

ProductList priceWhere your work runsPricing model
Microsoft 365 Copilot$30 a user a month, plus Copilot Studio creditsMicrosoft's cloudPer seat plus usage
Gemini Enterprise$21 to $60 a user a monthGoogle's cloudPer seat
Amazon Quick$20 to $40 a user a month, plus $250 an account and $3 an extra agent-hourAWSPer seat plus usage
NVIDIA AI Enterprise$4,500 a year for each GPU you run it on, for NVIDIA's AI software and support. The GPU itself is bought or rented separately.GPUs you own or rent; a software stack with no agent workspace, approvals or managed servicePer GPU, software only
Kybernetes OS$150 to $3,999 a month for the whole plan: agents, apps, approvals, audit, GPU control and our managed service. GPUs are paid to your provider, or are your own.Your server or cloud accountFlat allowance, no usage charge

The result

Finished work, with the evidence attached.

Your people spend their time deciding and reviewing. The agents do the rest, inside your walls, on the record.

Get started

See it on your own kind of work. Then prove it in 60 days.

Every demo runs on our reference Node, with a project built around the work your company does.

  1. Step 1 · 30 minutes

    A live demo

    A goal turned into a delivered result on the board: a pull request with its checks and a live preview, an infrastructure change waiting for approval, or a report from your kind of research.

    Free
  2. Step 2 · 60 days

    A paid pilot

    Your own Node on the Team allowance, onboarding included, working on your projects with your people. Credited in full to your first year when you sign within 30 days of the pilot's end.

    $3,000
  3. Step 3 · annual

    Production

    The plan that fits, billed annually. Move up as you add people, projects and GPUs, with add-ons for the months in between.

    From $150 / mo
Book a demo or a pilot.

Write to us and we'll set up a 30-minute demo around the work your company does.

info@kybernetesos.tech
Email us

Questions risk teams ask

Straight answers for security, legal and compliance.

Every answer describes how the shipped product works today. Your team can verify each one on a pilot Node.
What leaves our Node?

A licence check-in over HTTPS that carries the installation's identity and the licence it holds. By default also health heartbeats (numbers and states only, which your owners can preview), reports of the Node's own errors, and a daily count of the errors agents met; each can be turned off. Problem reports leave only when a person writes one. Prompts, answers, files, code and usage figures never reach us.

Can you, the vendor, reach our server?

During installation, yes, through an account you create for us. At the end you can remove it, and from then on we cannot act on the server until you grant access again. Updates arrive as signed releases that your owner approves, or that install automatically if you choose.

Who can see our prompts and code?

That depends on what each project allows. On your own hardware, only your organisation. On GPU lanes in your own provider account, traffic is encrypted end to end and only the provider's machines are trusted; on confidential GPUs the hardware encrypts memory too. A frontier lab sees only the projects you enable it for, under your own agreement with that lab.

What stops an agent from doing something harmful?

The platform, not the prompt. Agents work in throwaway gVisor sandboxes on a closed network, never hold your service keys, and cannot exceed the permissions of whoever started them. Payments, messages, production changes and merges into your main branch wait for a person by default, and everything is in the audit log.

Can an app reach our data or widen what agents may do?

No. An app's tools are calls your Node makes for the agent, within the app's rules, and its keys stay in the vault. An app's own code, when it has any, runs in a WebAssembly sandbox with no network and no files. An update that asks for anything new (a host, a tool, a looser default or a secret) waits for your owner, and Roll back returns the app to its version before.

What if a model provider cuts us off?

Move the affected projects to another model: an open model on your own GPU lane, your own hardware or another lab you have connected. Agents, skills, memory, files and history stay on your Node.

What happens when we reach a limit?

The Node holds back new use (an invitation, a new project, a lane start) and says why. It never deletes anything, and a lower limit never stops a running lane. GPU time is never counted, so a lane is never stopped for running too long.

Who do you sell to?

Businesses only, never consumers. Each client runs its own Node and answers for its own use of it, its customers' data and the providers it connects; we provide the software and the managed service, and we hold none of your data. The Terms of Service and How we handle data say so in full.

How does it help with compliance?

The settings laws ask for are built in and off until you choose them: retention periods, legal holds, requests about a person, a record of where data went and of every agent action. The Compliance page lists them by country, and your owners decide what to turn on.

What if our licence lapses?

The Node turns read-only. Nothing changes, your data stays intact and readable, and you can still delete it. A Node that cannot reach our hub for longer than its offline allowance (7, 14 or 30 days) locks until it reconnects.