The singularity, composed by you. on Tixim

Workflows

Mon, 01 Jan 0001 00:00:00 +0000

Not every wish deserves a workflow — the orchestrator routes quick things straight to an agent. A workflow is what you reach for when the work is serious: multi-step, reviewable, worth doing the same way twice. It is a directed acyclic graph of steps, defined in Nix, executed by the engine with the same discipline a build system applies to derivations.

Defined in Nix, discovered from flakes Shipping

A workflow is a flake artifact like everything else in Tixim: a Nix file that assembles steps, edges, instructions, and tools into a fixture the daemon discovers from its inventory (tix.workflows.<name>). Arguments are templated into steps at run time — paths, branch names, and prior outputs flow through filters like slugify and tojson instead of through string concatenation in prompts. The recipe is code: versioned, diffable, reviewable, and shared by pinning a flake.

Services

Mon, 01 Jan 0001 00:00:00 +0000

Workflows do the work and then disappear. Everything that must stay — state, credentials, listeners, project context — lives in a service: a long-running component the daemon supervises through a declared lifecycle. Thirty-three of them ship packaged today, from databases and proxies to per-project agent instances.

Declared, not deployed Shipping

A service is a Nix artifact under the same flake roots as everything else (services/ next to skills/, agents/, harnesses/). Its configuration is not a bag of strings: every service carries a settings schema, and settings are type-checked against it before the service ever starts. Images are built by nix2container without archives — layers come straight from the store, so a service image is exactly its closure, bit for bit, and rebuilds only when its inputs change.

Guilds & trust circles

Mon, 01 Jan 0001 00:00:00 +0000

Package registries ask you to trust an operator. CI badges ask you to trust a server. Tixim asks you to trust arithmetic: a build is certified when independent, economically committed parties reproduce it byte for byte.

Guilds put stake behind claims Building

A guild is a staking collective, modeled on Walrus staking: delegators back a guild’s pool, epochs advance permissionlessly, and commission changes only take effect two epochs later so delegators can exit at the old rate. One account can administer at most one guild, and one runner identity can build for at most one guild per epoch — so “independent reproductions” are actually independent, never one machine wearing three hats.

Security

Mon, 01 Jan 0001 00:00:00 +0000

Most agent frameworks bolt security on. Tixim starts from paranoia and builds outward: every layer assumes the layer inside it is already compromised.

The layers around a step Shipping

Left: what surrounds a running step. Right: what every piece of untrusted text must survive.

A workflow step never runs on the host. It runs:

The network

Mon, 01 Jan 0001 00:00:00 +0000

A flake is the on-chain unit of value: you create an account from a wallet, enroll your instances through scoped capabilities, publish flakes bound to encrypted repositories, and release them through multi-guild attestation. No layer below has an owner you must trust.

Six layers, one rule: Sui holds roots and proofs, everything heavy lives where it is cheap and content-addressed.

Sui — roots, policy, proofs Building

Small, root-oriented objects anchor everything that must be public and ordered: accounts and device capabilities (scoped, spend-capped, revocable), the flake registry, releases and build attestations, guild stakes and epochs, the cache index, the experience index — and registered service endpoints with their frontend releases, so a portal like tix.camp loads exactly what a project published and speaks to exactly the backend the project registered. Every state change emits an authenticated event. Heavy data never goes on-chain — Sui is the spine, not the warehouse.

Evolution

Mon, 01 Jan 0001 00:00:00 +0000

Most agent systems forget everything the moment a run ends. Tixim treats every run as evidence: what worked, what failed, what a human had to fix. Composed expertise plus compounding memory is the whole bet — intelligence spent once, dividends forever.

The loop: runs emit experiences, experiences distill into sharper experts, the ontology gate keeps every claim grounded in what exists.

Experiences, anchored Building

Workflow runs, service events, even manual notes can post an experience: the payload on Walrus, an append-only index entry on the flake — tagged, sequenced per epoch, readable under the flake’s own access policy. That gives downstream selection something honest to rank by: not stars, not marketing, but the recorded outcomes of real runs. The privacy filter runs before anything leaves your instance, and you decide per run whether an experience is private, project-scoped, or public.

Compute you control

Mon, 01 Jan 0001 00:00:00 +0000

Today, serious compute means a cloud account and a landlord. The pieces on this page are Tixim’s answer: make strangers’ hardware safe to use and strangers’ workloads safe to host — then nobody needs the landlord.

The baseline never changes: everything in Tixim is just an instance with the right service, and it runs anywhere — a laptop, a homelab, a rented box. tix.computer Horizon is the managed home for the instances you’d rather not babysit: high availability and privacy by default, registered on Sui like every other endpoint — and with nothing about it you couldn’t run yourself. Convenience, not lock-in.

Debug the recipe, not the run

Fri, 14 Aug 2026 00:00:00 +0000

Three months of vx-maintainer development, reconstructed from git history: how every failed workflow run became a patch to the recipe — more caching, more reuse, harder gates — until the runs got boring.

Building in the open, before it's ready

Thu, 13 Aug 2026 00:00:00 +0000

Why there is a landing page before there is a release, and what the first one will actually contain.

About

Mon, 01 Jan 0001 00:00:00 +0000

Tixim is a multi-agent development environment written in Rust with a Nix-native build and deployment system. It orchestrates AI-powered workflows — sequences of steps executed by LLM agents inside sandboxed containers — with DAG-based scheduling, encrypted secrets, and reproducible Nix-built harness modules.

tix and tixim

The pair is a client and a server. tix is the CLI that users and agents drive; tixim is the long-running daemon that exposes HTTP and gRPC APIs and manages services, workflows, secrets and the model gateway. The whole Rust workspace uses the tix- crate prefix, and the mark you see at the top of this page is the TiX wordmark.

Project statistics

Mon, 01 Jan 0001 00:00:00 +0000