Skip to main content

ZeroOS · AI task execution on your own servers

Let AI work through multi-step tasks on your own servers and hand back the results

Submit a task in the WebUI. The built-in CEO calls the model API you configure directly to split work into steps and assign them to open-source executors such as Hermes. Every step is saved so you can track progress, download outputs, retry failed steps, or send unclear outcomes to a person for review.

Your own Linux servers · The model API you configure · Hermes and other OSS executors

ZeroOS WebUI · Task details
Interface mock-up · sample data, not a screenshot

Review dependency-upgrade risks across 3 code repositories and write a report

Task status: Queued
Describe the job, the materials needed and the output you expect
Subtasks appear here once the CEO has planned the task

What you do: Describe the task and click “Submit task”.

What the system does: The task is saved, appears in the task list and is marked “Queued”.

Step 1/6

Use cases

For technical teams that want AI to carry out several steps in a row and keep a record of each one

ZeroOS is installed inside your network and maintained by your technical team. These are typical kinds of work that suit it. They are examples to help you decide, not customer case studies.

Software development and maintenance teams

Typical task

Investigate issues in an existing codebase, add tests and write up the changes.

What you get

Inputs, outputs and test results for every step are kept with the task, ready for code review.

Corporate IT and operations teams

Typical task

Check server settings and logs against a checklist and prepare an inspection report.

What you get

Results are filed by task, and any failed check can be retried on its own.

Teams working across Chinese, Japanese and English

Typical task

Organise technical material and draft multilingual documentation.

What you get

All output files are downloaded from the WebUI. To build up material across projects, MemoryBox can be added.

You may not need ZeroOS if

  • You only ask the occasional question or draft text. A general chat assistant is simpler.
  • You have no Linux server available and nobody to look after the installation.
  • Your process is fully fixed and just runs on a schedule. Your existing workflow or script tools are enough.

How it works

From submitting a task to collecting the results, in five steps

In the order things actually happen: who does each step, and where you can see it in the WebUI.

  1. 01You

    Submit a task in the WebUI

    Say what needs doing, which materials to use and what form the output should take. The task is saved the moment you submit it.

    Where to look: Task list
  2. 02Built-in CEO

    Plan the steps and assign them

    The WebUI back end calls the model API you configured, splits the task into subtasks and hands each to a suitable executor. Hermes is not involved in this step.

    Where to look: Task details · Subtasks
  3. 03Executors

    Do the actual work

    Open-source executors such as Hermes use tools to complete each subtask. Step counts, run time and recovery after interruption are handled by the executor’s own mechanisms.

    Where to look: Task details · Live status
  4. 04ZeroOS

    Save status and check ownership

    Every status change is written to PostgreSQL. ZeroOS also checks that the acting account owns the task and its output, and prevents the same task from being submitted twice.

    Where to look: Task details · Status history
  5. 05You

    Review and download the output

    When all subtasks are finished, the output files are filed under the task, ready to view and download in the WebUI.

    Where to look: Task details · Output

When something goes wrong

A step fails

The reason for the failure and any finished results are saved. Once you have confirmed nothing outside was affected, you can retry; finished steps are not run again.

The outcome is unclear

If an action was sent but no clear result came back, the system does not repeat it automatically. It keeps the record and routes the item to a person to check.

A restart or an interrupted run

Task status lives in the database, so after a restart you can pick up where you left off. Recovery inside an executor follows that executor’s own mechanisms.

Roles & features

Who does what, and which features are available today

ZeroOS separates planning the work from doing it. The built-in CEO plans, proven open-source executors do the work, and ZeroOS connects the two and keeps the records.

Built-in CEO

Understands the task, plans the steps, assigns subtasks and pulls the results together.

The WebUI back end calls the model API you configure directly. Model keys are stored on the server.

Executors

Carry out individual subtasks, such as reading and writing files, running tests or calling tools.

Mainly Hermes and similar open-source components; execution and recovery use the component’s own mechanisms.

ZeroOS task service

Publishes tasks, reports status, handles retries, sign-in, task and output ownership checks, delivery of results and WebUI updates.

Every status change is recorded in PostgreSQL and can be looked up later.

Feature status

Swipe horizontally to view full table
FeatureStatus 
Submit tasks, track progress and download output in the WebUIAvailableTask list, task details and output downloads.
Built-in CEO plans and assigns work using your model APIAvailableDoes not depend on Hermes; the model API is set in the admin settings.
Subtasks executed by HermesAvailableOther executors are assessed project by project.
Task status saved and still visible after a restartAvailableStored in PostgreSQL.
Retry failed steps; unclear outcomes go to a personAvailableFinished steps are not repeated.
Sign-in and task/output ownership checksAvailableOutput goes only to its task and to authorised accounts.
Failover of the main control service to a standby hostOptionalNeeds a second host. Verified in our internal test environment; see “Test evidence”.
Run-time credentials passed to executors through memory onlyOptionalVerified in our internal test environment; whether to enable it depends on your setup.
Pooling several model accounts and recording usageOptionalConfigured per project.
Connection to MemoryBox long-term memoryOptionalMemoryBox is a separate product that can be deployed alongside.
Human approval flow for high-risk actionsPlannedNot offered as a standard feature in the current version; requirements can be assessed during a pilot.
Other submission channels such as chat apps, email or a public APIPlannedTasks are currently submitted through the WebUI.

Based on our internal version records as of November 2026. “Optional” items need an environment check before installation; “Planned” items have no committed delivery date.

Test evidence

Internal test records: what we measured, and under which conditions

The two figures below come from Fidwell’s internal test environment. They have not been independently verified and there is no public report. During a pilot discussion we can walk you through the test procedure and show a summary of the records.

About 6.99 s (6,994 ms)

Main control service failover time

Type:
Internal measurement
Version:
ZeroOS internal development build, control-plane high-availability test stage
Date:
August 2026
Environment:
Two virtual machines in separate physical failure domains, PostgreSQL 16. Test environment with no production traffic.
Method:
With a standby controller already running, we force-killed the main controller process and timed how long the standby took to take over. We also checked that every late write from the old controller was rejected and that task records stayed consistent.
Sample / runs:
One recorded on-site failover
What it does not show:
Does not cover power-level isolation, whole-machine recovery, model-gateway recovery or wide-area network latency. Not re-measured in a customer environment.
247 passed, 1 skipped

Database regression suite

Type:
Internal measurement
Version:
ZeroOS internal development build (status record of 2026-08-22)
Date:
August 2026
Environment:
Test environment on a real PostgreSQL 16.15 database.
Method:
We ran the full database regression suite, covering task state transitions, concurrent contention, retries and cancellation. In the same batch the complete task path was run 100 times: mean 222.8 ms, P95 240.2 ms.
Sample / runs:
247 test cases; 100 runs of the complete task path
What it does not show:
Reflects the test environment only, not real failures in third-party services or customer systems. Timings change with different hardware and networks.
See architecture and estimate notes in the tech reference

Tech reference

Technical reference (collapsed by default)

For architects and technical evaluators. Contains: a comparison by tool category, the 7-layer architecture and 12 task states, 4 key mechanisms, human responsibilities and the 12 parts of a capability package, and pairing with MemoryBox plus usage accounting. Each item is marked Available, Optional or Planned.

Open the technical reference

Comparison by category

How ZeroOS differs from common AI tools

A summary of general traits by tool category, to help you judge whether ZeroOS fits your needs. It does not refer to any specific product or version.

Swipe horizontally to view table

AspectChat assistantLow-code / workflow platformKnowledge search (RAG)ZeroOS
Main purposeAnswering questions, writing, one-off analysisRunning a pre-configured process automaticallyAnswering questions from documentsSplitting a task into steps, running them and delivering the output
How work is split upThe user guides it turn by turnSomeone configures it on a canvas in advanceUsually not applicableThe built-in CEO plans it from the task description
Progress and recordsKept in the chat historyKept in the platform’s run historySearch and answer logsStatus of every subtask written to PostgreSQL
DeploymentMostly cloud servicesCloud or self-hosted, depending on the productCloud or self-hosted, depending on the productSelf-hosted on the customer’s servers
Best suited toEveryday personal assistanceFixed processes maintained visuallyLarge document sets, mostly Q&AMulti-step technical work that needs records and deliverables

Products within each category vary widely; check each product’s official documentation for its actual features. ZeroOS can run alongside these tools, for example sharing the same model API.

7 layers and task states

The 7-layer architecture

Each layer can be swapped for a comparable open-source component. Select a layer to see what it does and its current status.

L7 · Evidence and release layer

Available

Output comes with test results and change records

Components used
EvidenceEnvelopeVersioned release and rollback

Task output carries test results, a change list and a rollback point so it can be checked at acceptance. The full feedback-driven improvement process is still planned (see “4 key mechanisms”).

4 mechanisms that run through every layer

01
Identity and scope separation

Data and actions are separated by tenant, project and role, and checked outside the model.

02
Fencing tokens

CEO, task and model-resource leases each carry an increasing token; writes from an expired holder are rejected.

03
Transactional outbox

Status changes and events are committed together and can be re-delivered from the record.

04
Usage accounting

Costs are stored as whole numbers in millionths of a currency unit. If an executor reports no usage, it is recorded as “unknown”.

The 12 task states

From submission to completion a task moves through these states, and every change is written to the database:

Intakeaccepted → policy_check → ready
Accepted → admission check → ready. The original request is saved at this stage.

Tasks that fail the admission check end as failed and never run.

Executionleased → running → verifying
Assigned → running → checking the output.

Step counts and run time during execution are managed by the executor.

Waiting and retryretry_wait · awaiting_input · awaiting_approval
Waiting to retry, waiting for more information, waiting for confirmation.

awaiting_approval exists in the task model; offering it as a standard approval flow is still planned.

Finishedsucceeded · failed · cancelled
Succeeded, failed or cancelled.

Finished tasks and all their records are kept and can be looked up.

Key mechanisms

4 key mechanisms

For each one: the problem it addresses, how it works and how far it has been verified.

Stopping stale processes from overwriting progress

A write is accepted only when four conditions all hold

Available
Problem

After a controller failover or task reassignment, an old process may write late and overwrite newer progress.

How it works

Every write checks the revision number, the SHA-256 digest of the previous state, the current lease holder and the fencing token. If any one does not match, the write is rejected.

Verification so far

Internal test environment: after a controller failover, every late write from the old controller was rejected and task records stayed consistent (August 2026, one failover).

People and capability packages

What people stay responsible for

ZeroOS takes on searching, cross-checking, repeated checks and status tracking; the work below stays with people. Each executor unit is defined and accepted against the 12 parts of a capability package.

Handled by people

Business judgement
  • Setting business goals, trade-offs and delivery scope.
  • Deciding the system architecture and key interfaces.
  • Anything involving real identities, payments, contracts or formal releases.
  • Accepting the work against the test records.

The 12 parts of a capability package (CapabilityManifest)

Versioned
01
Runtime

Reproducible runtime and model connection spec

02
Resources

Hosts and compute quota used

03
Skills

Versioned working methods

04
Tools / MCP

List of permitted tools

05
Permissions

Allowed scope and forbidden actions

06
State and memory

Linked task state and memory scope

07
Data connections

Read-only or writable connections

08
Workflow

How status syncs with the task service

09
Dedicated UI

Interface for that line of work

10
Evidence

Test and change records it must produce

11
Supply chain

Dependencies and licences (SBOM)

12
Deploy and rollback

Install, upgrade and rollback steps

MemoryBox pairing · usage accounting

Using ZeroOS with MemoryBox

MemoryBox is Fidwell’s long-term memory product and can be used on its own. Paired with ZeroOS, it supplies material that is confirmed as current for the project before a task starts, and stores verified conclusions when the task ends.

01Optional
Context scoped to the project

Only material from the current project is passed to the model, cutting irrelevant history and cross-project mix-ups.

02Optional
Only verified conclusions are stored

Attempts that fail verification never enter long-term memory.

03Planned
Carry on after changing host or model

Move capability packages and memory data to a new host or model channel.

04Planned
Trace output back to its sources

Follow an output file back to the task record, the material used at the time and the original request.

About “70–90% less context”

This is a structural estimate in the technical white paper for passing project-scoped material instead of a full conversation history. It has not been measured; the real effect depends on how much material a task needs to look back at and on the model’s pricing.

Usage and cost records

For installations that connect several model accounts:

01Optional
Production tasks first

Production tasks get first use of model quota; development and test tasks borrow idle capacity and give it back when production work arrives.

02Optional
Resume at the provider’s reset time

Calls resume after the Retry-After or reset time returned by the provider, rather than after a fixed wait.

03Available
Whole-number accounting

Costs are stored as whole numbers in millionths of a currency unit. Routine health checks run as fixed procedures and use no model tokens. Missing usage is recorded as “unknown”.

Editions

Three ways to work with us, starting with a pilot

ZeroOS is in daily use inside Fidwell and is offered to customers through pilot evaluations. There is no public list price; we provide a written quote after assessing the factors below.

Option 1Software

ZeroOS self-hosted

Installed on your own Linux servers and PostgreSQL

Suits

Development or IT teams with operations capacity who want to run AI tasks inside their network

Delivery

Software licence plus installation support

Included
  • ZeroOS installation package and WebUI
  • Setup guide for the built-in CEO and model API
  • Configuration for the Hermes executor
  • Installation, upgrade and rollback guides
Option 2Combined

ZeroOS + MemoryBox

Adds long-term storage of material and decisions across projects

Suits

Teams with long-running projects that need to build up history and keep projects separate

Delivery

Both products installed together; dedicated hardware assessed per project

Included
  • Everything in option 1
  • MemoryBox installation and project scope setup
  • Integration guide for the two products
Option 3Tailored

Task-specific capability package

Executors, tools and acceptance criteria set up for one kind of job

Suits

Teams with a clearly defined job who want a ready-to-use process

Delivery

Custom development plus maintenance

Included
  • Capability package definition: runtime, tool list, permissions, test and rollback steps
  • Test cases and acceptance records for that job
  • Can be added to an existing ZeroOS installation

What you need before installation

  • One or more Linux servers and a PostgreSQL database.
  • A model API you can use: a commercial model or one you host yourself.
  • Agreement on what the pilot task may read and change.

How a pilot works

  1. 01Discuss requirements

    We confirm the task to pilot, your current environment and the results you expect.

  2. 02Agree the scope

    We put the test environment, read/write scope, acceptance criteria and rollback plan in writing.

  3. 03Trial in a test environment

    Real tasks run in an isolated test environment and the results are recorded.

  4. 04Review the results

    We review them together against the acceptance criteria, then you decide whether to go further and which option fits.

What the quote is based on

  • The option: self-hosted, combined with MemoryBox, or a task-specific package
  • How many tasks run at once and how many servers are involved
  • Whether MemoryBox or a standby host is needed
  • The amount of custom work and the maintenance arrangement

FAQ

Frequently asked questions

How mature is ZeroOS today?

ZeroOS is in daily use inside Fidwell and is offered to customers through pilot evaluations. The feature status table under “Roles & features” shows what is available, what needs extra setup and what is planned.

How is it different from low-code workflow platforms or agent frameworks?

ZeroOS plans tasks, saves their status and delivers the output, while open-source executors such as Hermes do the actual work. Workflow platforms suit fixed processes configured visually, and the two can run side by side. Whether to replace an existing tool is best decided task by task during a pilot discussion.

Do I have to use a particular model?

No. The built-in CEO calls whichever model API you configure in the admin settings, whether a commercial model or a self-hosted open-source model with a compatible interface. The models used by executors are also set at installation.

Can I use ZeroOS without MemoryBox?

Yes. ZeroOS keeps its own task records and does not depend on MemoryBox. Consider adding MemoryBox when you need to build up material across projects and keep projects separate.

Where are data and keys stored?

ZeroOS runs on your servers and task records are stored in your PostgreSQL database. The model keys used by the built-in CEO are kept on the server and never shown in the browser. When an external model API is called, the content sent to it is subject to that provider’s terms.

Request a demo

Leave your details and we will arrange a demo and pilot discussion

Only your name and a way to reach you are required. Everything else can wait until we talk.

What happens after you submit

  1. 1
    Your inquiry is saved

    Your details are stored in our inquiry records and a reference number is shown on screen.

  2. 2
    A consultant contacts you

    During business hours, using the contact details you gave, to learn about your task and environment.

  3. 3
    Demo or pilot

    We show you the WebUI if helpful, or move ahead with the steps in “How a pilot works”.

Request a demo

Only two fields are required.

Dalian Fidwell Technology stores what you submit and notifies our team by email. We use it only to contact you about this request and keep it for up to 24 months. To access or delete it, email fidwellservice@fidwell.cn or call +86-411-81981709. By submitting, you agree to this handling of your details. Full privacy notice