Rubian/Kestowv Documentation

Finding files, turning a useful command into a reusable program, keeping work running and recovering a failed service are different problems. Rubian and Kestowv address these parts of working with a computer, from the interactive session to machine operations.

Rubian is a programmable operating environment for people and programs: discover files and software, work with returned data, reuse libraries and manage persistent workspaces. Kestowv is the systems foundation, with research into useful computation and a supplied pilot for service control and workload evaluation. Start with a problem below, then follow its manual.

Problems We Solve ↗

Choose a problem. Follow it into the manuals.

Rubian

Finding the right files takes too much work.

Start with an inventory of available files, directories and commands. Find what you need, then use the returned paths in your next operation.

Find and prepare your work →

Rubian

Repeating a task means rewriting the same steps.

Supported commands return values you can inspect and combine. Turn an interactive sequence into a reusable Ruby method with explicit inputs.

Turn commands into reusable work →

Rubian

An installed library still needs a way into your work.

Forge discovers compatible Ruby libraries and exposes supported functions, values and objects through the working environment.

Use compatible libraries →

Rubian

Reopening a prompt doesn’t recover your place.

Configured persistent storage keeps working files. Named projects and session notes keep the work organized and the next step recorded.

Keep files and working context →

Rubian

Long-running work ties up the prompt.

Run Ruby work as a named background job, continue at the prompt and retrieve its result or failure. Recurring work has its own status and controls.

Run and inspect continuing work →

Rubian

People and programs need more than a shared login.

Accounts, managed homes and permissions give work an owner. Configured program workspaces can call commands and exchange files, messages and tasks.

Give people and programs a workspace →

Kestowv pilot

A running process isn’t always a healthy service.

Separate the service you want from the state you observe. The pilot supports configured health checks, bounded restart attempts and release recovery.

Inspect failure and control recovery →

Kestowv pilot

One fast run doesn’t prove a change is better.

Declare the workload and acceptance checks, compare baseline and candidate, and keep failures in the result. Judge correct completed work, not a timing alone.

Evaluate a change against real criteria →

Resume a job with its next step recorded#

Suppose you're reviewing a machine inventory. You need to leave the work unfinished and return without guessing which project you used or what still needs checking.

In a Rubian environment with the project kit and an authenticated workspace, list your projects first:

proj_list

If inventory-review is in that list, select it and retrieve its location. Otherwise, substitute a project you already have:

proj_cd('inventory-review')
proj_path

The selection returns the project's path. Its working files, source and notes remain grouped under that project; selecting it doesn't change your host shell's current directory or execute its code.

Before leaving, record the next action:

session_log!(
  'Inventory review: check the two unassigned hosts next.'
)

That appends a timestamped note to your session record and returns the record's path. kit_status shows where that record lives. The note supplies the intent that command history alone doesn't capture. See Projects and session notes for creating a new project, writing files and resuming work.

Test whether a machine-level change helps#

For an infrastructure engineer, the question may be different: does a change complete the same work correctly, with acceptable latency and failure behavior? The Kestowv pilot supports a single check, a baseline-versus-candidate comparison, or repeated work over a stated duration. You declare the workload and acceptance criteria, then inspect the results, including failed runs.

Start with Workload evaluations. A useful result names the tested machine, inputs and conditions. Faster throughput by itself doesn't establish lower energy use or better reliability.

What you can use today#

The references below cover supplied Rubian evaluation environments and the Kestowv enterprise pilot package. Features vary by package: project tools require a configured workspace, and job, agent and collaboration commands aren't present in every build. Check Availability and compatibility before choosing a guide.

Arcturus is reliability and management software built on Rubian and Kestowv, spanning individual machines, home clusters, fleets and data centers. Its predictive-maintenance scope extends from machine conditions to dependencies across the data-center stack. Current Arcturus browser demonstrations use sample data. Valux is the broader operating-system research effort. Core is the user- and agent-facing application environment made programmable by AI, with selected interface work intended to contribute to that research.

To discuss an evaluation, tell us the workload, the environment it runs in and the result you need to test. That gives us a concrete basis for selecting a component, version and evaluation scope.

Work in Rubian#

Use the capability guide to find the relevant manual. Begin with Start a Rubian session and Startup, discovery and recall to understand what the environment prepares and how to find your work. The command language then explains how returned values make operations reusable.

The manuals cover file operations, text processing, editing, account controls, Forge libraries, Taskman and networking. For sustained work, use projects and notes, background jobs, recurring work, agent workspaces and collaboration.

Operate a Kestowv pilot#

The pilot manual begins with a small, declared workload. It then covers the command utility, configuration fields, service and release operations, and workload evaluation.

Use the pilot documentation supplied with your evaluation package when it differs from this edition. The availability table explains which interfaces these manuals cover.

Explore Arcturus#

Arcturus documentation introduces the reliability and management product. Its current public demonstrations show data-center investigation and machine-level operational work using sample data. Those guides document the available investigation workflows.

Understand Valux#

Valux documentation describes the broader operating-system research, the role of its components and its relationship to Arcturus. It also explains how to scope an evaluation of the components available today.

Resolve a problem#

For command errors, missing files, unavailable jobs or a failed pilot check, use Rubian and Kestowv troubleshooting. Include the product version, the operation and the exact error when reporting a problem; remove credentials and customer records from any accompanying output.