Start Here

Choose the right Lenso path and get to a verified local system.

Lenso is an agent-ready modular app framework for Rust business systems.

Start with one deployable backend, add business modules, then verify the system through the Runtime Console. These docs are organized around the two jobs users usually have on day one:

• Host builders create and operate the app that loads modules.
• Module authors add business capability through manifests, routes, actions, runtime functions, and optional console surfaces.
• Service owners move stable boundaries into independently operated Autonomous Services without making Kubernetes a local-development requirement.

Choose Your Path

• New host app: read Host Quickstart and finish with the API, worker, Postgres, and /console running.
• Product-shaped app: read Product Blueprints when you want a generated service-ready app plus supported addons.
• Host configuration: read Configuration when you need real env variables for profiles, CORS, Redis, telemetry, Console paths, or service tokens.
• Host composition: read Host Composition when you need to understand profiles, HostBuilder, linked modules, service sources, and module startup toggles.
• Platform model: read Platform Concepts to understand manifests, host-owned runtime work, and remote boundaries.
• Runtime evidence model: read Runtime Stories to understand Lenso’s story graph, correlation model, and operator-readable business evidence.
• Autonomous boundary: read Autonomous Services before moving Workloads, Store, workflows, identity, and reliability out of the Host.
• GA operations: read Single-Region GA for the exact supported component set, evidence gates, migrations, and Contract Retirement.
• Failure planning: read Reliability and Recovery for degraded modes, scenarios, restore, disaster recovery, and control-plane outage behavior.
• Production trust: read Support and Security for support manifests, SPIFFE identity, secrets, Console access, and approvals.
• Manifest fields: read Manifest Reference when you need exact ModuleManifest fields, builder methods, capabilities, route metadata, and lint categories.
• API integrations: read API Clients when consuming Lenso HTTP APIs from OpenAPI or handling the standard error envelope.
• Contract work: read Contracts and Checks before changing generated artifacts, OpenAPI, gRPC, or architecture-sensitive code.
• Release safety: read Checks and Release when you need to know which just gate matches a code, contract, Console, or release change.
• CLI work: read CLI Reference for lenso host, lenso app, lenso serve, lenso module, module release checks, catalogs, marketplace compatibility, and Console package plans.
• Install flow: read Module Installation when you need to know what the CLI writes locally and how a running host registers modules through the admin API.
• Catalogs: read Module Catalogs when you need the difference between discovery, install, and the official fallback catalog.
• Deployment: read Deployment before packaging a generated host, publishing a hosted Console bundle, or wiring migrations and workers.
• Data changes: read Database and Migrations before adding host-linked module SQL or running deploy migrations.
• Operations: read Observability for health probes, structured logs, OTLP traces, and Runtime Console runtime views.
• Host verification: read Runtime Console and confirm module health, data, actions, and runtime evidence.
• Broken local setup: read Troubleshooting to diagnose blank Console, missing modules, remote service readiness, CORS, Redis, generated artifacts, busy ports, and release-gate failures.
• Built-in auth: read Built-in Modules and install auth, auth-anonymous, auth-password, or auth-device into a host.
• Rust module: read Module Authoring and scaffold one useful capability with a smoke check.
• Operator surfaces: read Admin Surfaces when the module needs data pages, actions, query values, or custom Console UI.
• Auth and permissions: read Auth and Capabilities when a module needs actor identity, session integration, or capability-scoped operations.
• Runtime work: read Runtime and Lifecycle when you need handlers, lifecycle declarations, background workers, or remote runtime endpoints.
• Console package: read Console Packages when a module ships a typed React package for the Runtime Console.
• Out-of-process module: publish a service-backed module release, then use Module Installation to install it into a host.
• Agent-assisted development: read Agent Development and use skills, scaffolds, checks, and /console evidence.
• Working reference: read Examples and run the support-ticket or account-profile smokes.

Concepts

Agent

Host

Operate

Module

What to install

• Public skills: npx skills add lenso-dev/skills.
• lenso@0.3.33 is the GA Rust facade and Host runtime line.
• @lenso/cli@0.2.13 and lenso-cli@0.2.13 expose the same published CLI surface.
• @lenso/service-kit@0.1.0 is the public TypeScript Service authoring path.
• Runtime Console 0.1.2 is distributed as a release archive and bundled into generated hosts.

Mental Model

Lenso is modular-first and service-ready, but it is not a Kubernetes-first microservice platform. Build one deployable system first. Split selected modules only when their ownership, data, and operational boundaries are real.