Developer Program

Build the layer between intention and working software.

Codex, Claude Code and Ollama are engines. Lazing is the cockpit, scope and trace layer around them: local-first, bounded and built for real work.

Apply as Founding Developer Read the layer

Scoped by designCredentials, memory and actions stay inside the field that owns them.

Bring your enginesCodex, Claude Code, Ollama and local agents plug in as capabilities.

Traceable workEvery decision and handoff can leave an inspectable local record.

Why Builders Care

Useful agent power without the usual sprawl.

Less integration glue

Build one pack that can produce plans, review panels, trackers or decisions from intent.

Reusable domain logic

Turn expert workflows into pack contracts instead of repeating prompt rituals.

Fast local iteration

Prototype against a local runtime before any hosted surface or marketplace exists.

Local First

Install the host. Add capabilities. Keep authority close.

The developer program starts with the runtime itself: local/VPS install, scoped adapters, SQLite trace and packs that make useful systems appear from intent.

git clone https://github.com/MaximilianGerhardt/lazing.git
cd lazing
./install

# planned direction
lazing adapter add codex
lazing adapter add claude-code
lazing adapter add ollama
lazing pack dev ./packs/product-launch

System Stack

The runtime is not another SaaS dashboard.

It is the control layer for bounded work: fields, packs, adapters, confirmations and trace. Every object has a reason to exist and a scope where it belongs.

Field runtime

Local machine or VPS owns scope, credentials, field memory and execution authority.

Manifestation Packs

Reusable domain logic: data needs, risks, confirmations, outputs and trace rules.

Agent adapters

Codex, Claude Code, Ollama and OpenAI-compatible engines become scoped capabilities.

Trace ledger

SQLite-first records for decisions, changes, resolutions and agent handoffs.

Pack Anatomy

A pack is a small operating system for one kind of outcome.

Packs turn expert behavior into repeatable systems. They do not own the user; they ask for the right inputs, create the right surface and leave a clear trace.

Intent

Which human request should this pack understand?

Lens

Which perspective shapes the system it creates?

Inputs

Which data is needed before useful work starts?

Risk

Which decisions need explicit confirmation?

Manifestation

Which interface, document, workflow or tracker appears?

Trace

What should be recorded for later review?

Contribution Tracks

What builders can own first.

Adapter authorsManifestation Pack maintainersLocal runtime integratorsBenchmark and eval buildersSecurity and privacy reviewersDocs and example authors

Developer Use Cases

The first technical work should make scope easier to trust.

Codex adapter

Shape how Codex becomes a scoped capability instead of an owner of the whole context.

Ollama path

Help make local models useful inside fields, packs and traceable resolutions.

Trace viewer

Build the surface that makes decisions, changes and agent handoffs inspectable.

Pack test harness

Create checks that keep creator packs honest before a public showcase exists.

Founding Circle

Apply before the API surface settles.

The first Founding Developers will influence adapter boundaries, pack contracts and the trace layer before Lazing hardens.

Founding Developer

Own a contribution trackPick a concrete surface: adapter, trace tool, pack test harness, eval, docs or runtime UX.

Influence the interfaceEarly technical contributors help harden pack contracts before the API surface settles.

Get early architecture callsStrong applicants can join private review loops around adapters, scope and trace.