The harness
A coding agent you can actually own.
Jeden is Wisent’s private coding-agent harness: local policy, controlled tools, durable sessions, and model freedom. One local process keeps the whole loop — from the first file read to the final verification — on your machine and under your rules.
What Jeden is#
Jeden is a harness for AI agents built from real-life experiences. It routes models intelligently, manages credentials, and understands how to pursue, complete, and verify tasks over time — while the agent’s inference path, spend attribution, and tool permissions remain under your control rather than a third-party hosted agent’s. It is compatible with OpenAI, Anthropic, Kimi, and any other model reachable through an OpenAI-style endpoint.
Jeden is not a hosted or multi-tenant service; it is a local harness, and its local runtime is usable without a hosted Wisent account. It runs as a single local process: nothing but that process reads the checkout. By default model inference goes through Brama; an explicitly selected OpenAI-compatible endpoint instead receives calls directly, with a process key or Jeden's optional private token list.
Jeden serves two audiences:
- Engineers, who run interactive and one-shot coding tasks in the terminal with local approval over every write and command.
- Tooling and automation, which drives the same harness through its machine interfaces (RPC, ACP, headless mode, SDKs) inside editors and workflows.
Design contract#
Jeden separates five concerns. Each part stays visible, inspectable, and local — the model can reason freely, but the harness decides what may actually happen.
- Inference — an explicit
JEDEN_MODEL_ENDPOINTsends OpenAI-compatible calls directly to a provider, usingJEDEN_MODEL_KEYor Jeden's optional local token list. Otherwise calls go through Brama with HMAC-signed chat completions; the signing secret never leaves the process. - Policy — the harness prompt and approval rules are explicit and local.
- Tools — a small allowlisted registry enforces path jails and write or command permission.
- Run loop — the model may return native tool calls or strict JSON actions that enter the same local execution loop.
- Pursuit adapter —
jeden pursuemaps the separately owned Pursuit engine stages onto persistent planner and executor conversations plus fresh read-only reviewers.
How a task runs#
A task enters through CLI, TUI, RPC, ACP, headless or an SDK. Jeden records the original request before a model call and uses a separate read-only conversation to record its acceptance requirements. The execution loop proposes results; a fresh verifier reads real observations before the native controller accepts completion. A new question does not erase earlier work. A repair is accepted only at the level of its class: intake gives every defect, and every task that repairs something broken, the criteria that the class is named, its other instances in the product are searched for and named, and the mechanism that let it arise is repaired; the verifier returns continue for a change that removes only the reported instance, special-cases the reported input or suppresses the symptom.
A standing rule the operator states holds in every later turn of every session, whatever a session keeps or compacts. The model a turn runs on reads each operator message, in the background, for instructions or corrections about how the agent must work from now on; each one is kept verbatim as a rule memory of the operator's scope, in the fleet database or, without one, Jeden's own SQLite file. Every turn's system prompt carries the kept rules after the operator contracts. The session ledger records each reading as a memory_mutation with source: operator_rules: the rules kept, or kept: false with the model and the reason nothing was kept. A memory store that cannot be read is said on standard error and in the prompt, so a turn without the operator's rules never looks like one that has none. The real journey is JEDEN_BIN=… JEDEN_TEST_SOURCE_REVISION=… JEDEN_TEST_PROVIDER_ENDPOINT=… JEDEN_TEST_MODEL=… JEDEN_TEST_PROVIDER_TOKEN_A=… node tests/operator_rules/journey.mjs.
Tool schemas are derived from each tool’s input contract and sent with the model request. Tool results are recorded in the session and returned to the model until it produces a final answer. File mutations return Jeden-native visual diffs and previews, and oversized tool results are persisted as session artifacts and replaced in the model loop with a compact reference.
Failure handling is fail-closed. Without an explicit direct provider, model requests go to Stado's inference alternatives; where Stado cannot be run or refuses, the provider in Jeden's token store stands in (see Run without Brama or Stado); with an empty store the run stops before a model call naming both causes. Jeden takes no lease of an account and holds no Brama credential: the alternative Stado asks keeps its own. Direct requests rotate the private token list for the same endpoint on HTTP 401, 402, 403 or 429 before model output is visible. Otherwise transient model errors move to the next configured route without a backoff sleep. An exhausted pool retains the last actual refusal; no credential or route failover occurs after output becomes visible.
Oko's fleet starts Jeden as its default harness (oko sessions start --harness jeden, oko sessions resume). Jeden reads no Brama address from the environment Oko hands it: its model requests go through Stado's inference alternatives (see Other products), and a BRAMA_URL Oko sets for a lease proxy is not used. Each step records the route it was served on as a model_route event, which is where oko sessions agents and Oko's model policy read the model a Jeden session works on; oko sessions screen and oko sessions send read and type into Jeden's terminal as into any other. oko sessions resume continues a Jeden session in place with --resume-session, so the message reaches a Jeden holding the session's history and chat memory. The real journey is JEDEN_BIN=… OKO_BIN=… JEDEN_TEST_SOURCE_REVISION=… JEDEN_TEST_MODEL=… JEDEN_TEST_STADO=… node tests/fleet/oko.mjs, where JEDEN_TEST_MODEL is any model oko sessions start --model takes. The model is played through Stado's attestation alternative: each prompt is answered by a statement the journey records (stado capabilities attestation record), its word in upper case. Nothing of the person's own Oko, Stado or Jeden is read or changed and no account is signed in: every program runs with the run's own HOME and Oko settings domain, and oko serve --socket serves a broker of the run's own; Oko finds Jeden under that HOME's ~/.stado/bin. The journey starts a Jeden session through that broker, waits on the transcript's file events for the first served step, requires oko sessions agents to report the served model, reads the answer from oko sessions screen, hands a second prompt with oko sessions send and waits for its served step, resumes the session with oko sessions resume and requires the third answer in the same ledger beside the first two, then ends its terminals and stops its broker. A pass that meets a request no statement answers yet ends its terminals and runs again from an empty workspace once the statement is recorded. Commands and observations stay under .build/fleet-oko.
Model and tool execution keep native interaction receipts at the shared execution boundary, independently of tool visibility and completion policy. An operation_request keeps the model messages or original tool arguments before execution; its operation_result names that request through requestEvent and retains the returned content or actual failure. operationKind distinguishes model queries from tools even when a tool is itself named model. Both streamed and buffered model calls are included, so compaction, memory summaries, operator-rule readings and lifecycle classification do not rely on the main action parser to keep their answers. A call with no conversation creates a native session and holds its transcript open throughout execution, and nested tools inherit that session. Private reasoning callbacks are not recorded by this observation path.
A request that cannot be recorded is refused before execution. A result write failure reports the failed ledger operation and keeps an original execution failure alongside it; structured tool output carrying ok: false is failed, not successful merely because an object was returned. A streamed failure keeps the received answer text and the actual failure separately. An unmatched request means no terminal result was recorded, never that the operation succeeded. Inspect the complete data with jeden export <session> <output.json>; text-only jeden show is not the operation ledger. In Desktop's Transcript, model queries appear under Models, tool invocations under Tools and failed results under Failures. Select the record to read its full input or outcome in the inspector's Summary; Copy Details retains the request reference and complete event data.
The real recording journey is node tests/tracking/journey.mjs. Supply JEDEN_BIN, the committed JEDEN_TEST_SOURCE_REVISION, JEDEN_TEST_STADO and the known expected JEDEN_TEST_TRACKING_EXIT, plus the actual archive candidate JEDEN_TEST_LAKE_BIN, its JEDEN_TEST_LAKE_REVISION and the normal TRANSCRIPT_LAKE_SECRET_FORMATS declaration. The model is played through Stado's attestation alternative under the run's own HOME: with exit 0 the journey states each answer (the requested text, a read_file call, the read's report); with another exit no statement answers the request, and JEDEN_TEST_TRACKING_CAUSE names the refusal it expects. The journey retains commands, exit statuses, source and binary identities, native exports, masked canonical events and its verdict under .build/tracking. It checks the model content, completed auxiliary buffered calls, successful and missing-file reads, an unwritable-session-root refusal, and native-to-archive outcome correlation without fabricating operator messages; archive adoption alone discovers the genuine isolated native session root through its fixture HOME and never changes the masking declaration. A refusal-only run does not qualify successful inference or tool execution, and the CLI journey alone does not qualify the rendered Desktop surface.
The SDK recording journey is kompilator test --manifest-path Cargo.toml --test tracking-api -- standalone_calls_keep_actual_effects_and_refusals --ignored --nocapture, with JEDEN_TEST_SOURCE_REVISION and JEDEN_TEST_MOVE_PROGRAM naming an actual move executable. It invokes the public tool runtime, materializes a real file, proves a permission-refused write left no file, then relocates only its own isolated session with the real process tool. The result-write refusal must retain both the failed original ledger path and the operation's observed destination; the relocated ledger must retain the pre-execution request without inventing a terminal result. The packaged sandbox helper and real external program must work. This journey uses no model substitute, and it does not qualify inference, archive adoption or graphical rendering.
A successful native CLI journey also retains tracking-capture.json, with the actual read sessions, unchanged transcript hashes, returned model decisions and source/binary identities. It is generated from real executions before archive adoption, not a handwritten substitute for a runtime. Transcript Lake's LAKE_TEST_TRACKING_CAPTURE and Oko's OKO_TEST_TRACKING_CAPTURE consume that file for their maintained adoption and decoder journeys. Keep the recorded native files and actual archive partitions with it; a capture alone is not a qualification verdict.
An export refuses an event it cannot serialize instead of replacing it with null, and an invalid session directory identity is named with its actual path. Text-only recall keeps recorded text parts from multipart messages and leaves non-text parts to the full JSON export; a missing role, missing content or malformed text part is reported with its message and source instead of becoming an empty answer. Desktop treats missing or unknown terminal outcome status as malformed evidence under Failures, never as a completed result. Pending-action identifiers are opaque UUID-based values: use the returned identifier rather than deriving one from a timestamp or process-local counter.
An operation_request without its required input is malformed evidence under Desktop’s Failures filter for both model and tool records. Its diagnostic keeps the operation name and full received data; it is not hidden under Models or Tools. An explicitly recorded JSON null remains a present input, not a missing field.
Retained tool_call and tool_result records follow the same rule: a missing tool name or required input/result is malformed evidence under Failures. A tool result’s explicit boolean ok: false is also a failure, including records written before execution observations were added. Their Summary shows the complete recorded input or result rather than selecting an error sentence or a path and discarding the remaining diagnostic fields. A present null value is not an absent payload or a claim of successful execution.
Summary and Copy Details encode the complete decoded payload with the platform JSON encoder. Quotes, backslashes, property names and control characters therefore retain their JSON meaning rather than being interpolated into an invalid document. An encoding refusal is shown with its actual cause, never replaced with an empty object or null. Typed JSON decoding selects another member only after an exact-path type mismatch or an exact-path integer decoding refusal when checking another numeric representation. Nested-value failures and the final numeric decoding refusal retain their actual error and coding path.
In the Jeden Desktop repository, node tests/tracking/journey.mjs consumes the real recording journey’s retained tracking-capture.json. Supply JEDEN_DESKTOP_TEST_SOURCE_REVISION, JEDEN_TEST_SOURCE_REVISION and JEDEN_DESKTOP_TEST_TRACKING_CAPTURE. It requires the clean committed Desktop candidate, checks genuine transcript digests, and uses that repository’s registered JedenSessionsTests target with dependency auto-resolution disabled. The native reader, actual filter state and selected-event model consume unchanged model/tool requests, paired genuine successful/refused legacy tool calls and results, and isolated copies with an absent or null payload. Original captures stay unchanged; corrupt copies are negative forensic artifacts, not newly produced or checksum-repaired native executions. Legacy failure expectations come from the actual recording capture’s observed read outcome, not a word classifier. Commands, statuses, source and loaded-test executable digests, native observations and final source inspections remain under Desktop’s .build/tracking. A missing native report, skipped case or failed final inspection cannot pass. This consumer journey neither performs model inference nor proves the rendered Transcript screen.
An escaping-sensitive genuine model request is a required fixture for that native journey: a capture containing only safe plain text cannot qualify the serializer. The test parses the actual Copy Details representation with the standard JSON decoder and checks its semantic payload against the retained source, including the same check on legacy tool records. It does not construct a replacement model answer or treat an unexecuted test source as evidence.
Desktop preserves signed and unsigned whole JSON numbers without first rounding them through floating point. Integer-only metadata such as a transcript step is projected only when the recorded value is exactly representable as a platform integer. Finite out-of-range values do not trap the app, and fractional values are not truncated into invented steps; the original decoded value remains available in Details. Integer strings use strict integer parsing, not a floating-point conversion. The native retained-capture journey loads isolated copies carrying the platform’s largest finite and smallest positive numeric step values, signed and unsigned integer limits and a fractional numeric string. It independently decodes the actual Details output into the matching standard integer or string type, checks the selected-event projection and readable neighbours, and preserves the genuine source files.
Native numeric timestamps and numeric timestamp strings use Unix seconds, matching the native recorder. The reader does not infer milliseconds from a value’s magnitude. ISO timestamps with whole or fractional seconds use the platform ISO parser; a parse refusal remains unavailable rather than becoming an invented date. The same retained-capture journey derives a whole-second timestamp from a genuine recorded event, then verifies numeric seconds and both ISO representations through the actual native reader and selected-event model. A source definition or a clean SourceKit diagnostic is not an executed qualification.
Desktop state and transcript readers distinguish an actual no-such-file read error from a permission, storage or decoding refusal. A failed metadata existence probe cannot turn a refused read into an absent file. The native recording-consumer journey copies genuine state, removes only its isolated parent’s observed search permission, independently observes the real Foundation refusal and failed existence probe, then requires the native reader’s same path and cause. It restores and checks the exact original permissions and bytes, confirms the reader works again, and separately checks genuine absence; a missing host refusal or failed restoration cannot qualify.
Native transcript decoding retains the actual error and physical source line instead of counting unreadable records without their cause. Missing required event identity, payload type or payload data is a named refusal, not an invented line identifier or null body. Readable neighbouring records remain available, and an unreadable final record is not silently discarded. Opening-task I/O and decoding failures remain failures rather than classifying the session as an empty automation run; unavailable activity timestamps are reported rather than replaced with a fabricated date.
That same maintained native journey copies a genuine transcript for missing identity, missing payload type, missing payload data and a physically truncated final JSON record. It requires each actual native refusal, its field or decoder cause and source path, and the unchanged identities of readable neighbouring records; it also checks the genuine source bytes again. Its child runs in a fresh home inside the checkout’s ignored build directory, without inherited error-intake credentials, so forensic negative cases cannot report invented operator defects. An absent fixture, unavailable host refusal or missing native observation remains a failed qualification, not a skipped pass.
The multipart recall journey is kompilator test --manifest-path Cargo.toml --test tracking-api -- multipart_recall_keeps_real_recorded_text --ignored --nocapture. Supply JEDEN_TEST_SOURCE_REVISION, an absolute JEDEN_TEST_MULTIPART_SESSION pointing to a genuine native session, and its independently identified first text part as JEDEN_TEST_MULTIPART_TEXT. The fixture must actually contain mixed text and non-text content; a handwritten journal or a plain-text-only session cannot qualify this path. The journey invokes the candidate export CLI and the public recall tool, checks that the real recorded text reaches its consumer under the recorded speaker and the source journal stays unchanged, and retains actual outcomes and artifact identities in .build/tracking. Only its own recording session is writable.
The terminal redraws when keyboard input, a resize, worker output or worker completion arrives, not on a polling timer. Approval questions use that same event source. The busy indicator advances with observed activity; a quiet worker does not animate it. Foreground commands and external editors receive stdin without a competing reader.
Model discovery is not a gate either. A catalog read that fails, is rate limited or answers 5xx leaves the catalog unread rather than answering about the configured model, so the run says so on standard error and sends the request anyway; the gateway that serves it decides. A catalog that does answer still refuses an unknown or unavailable model by name, and an explicit non-retryable refusal still stops the run before any provider spend. Brama catalog reads revalidate with the catalog's etag, which Brama answers with 304 when nothing changed, unless BRAMA_CATALOG_TTL_MS declares how many milliseconds a fetched catalog is served first. An unreadable or nonnumeric value is a configuration refusal naming the variable and its cause, not a silent revalidation choice; direct-provider mode does not read this Brama setting.
An answer the model delivers can still be unusable: malformed JSON or a provider response cut off by its output budget. The turn quotes the exact refusal back to the model and continues while the observed failures change, within any caller-supplied --max-steps. Repeating the same malformed answer or the same provider cut-off cause after correction stops with that cause and repeatedFailure: true in the recorded model-answer violation. A changing answer is not rejected by a fixed correction count; the retained request stays open when correction fails.
Stream recovery has no fixed attempt ceiling. Before any output is visible, a typed context overflow can consume the next configured context-promotion route or compact existing history; a cut-off answer can use the answer-repair path. Each continuation changes the request rather than replaying an unchanged transport failure. When no recovery applies, the original model error ends the turn and remains recorded. CLI, terminal and RPC callers share this conversation behavior.
The real recovery journey is node tests/model/recovery.mjs. Supply JEDEN_BIN, JEDEN_TEST_SOURCE_REVISION, JEDEN_TEST_RECOVERY_SCENARIO and the OpenAI-compatible provider JEDEN_TEST_PROVIDER_ENDPOINT (with JEDEN_TEST_PROVIDER_TOKEN_A where it takes a key). It is the one model journey Stado's attestation alternative cannot play: a promotion follows a provider refusing a prompt longer than its route takes (context_length_exceeded), and a statement answers a request, it never refuses one. Jeden calls that provider directly under the run's own HOME with no Stado on the PATH. The scenario names a real starting model, ordered promotions route objects, a promptFile and expectedText. Use a prompt that genuinely exceeds every route before the last accepting one. The journey verifies every promotion, then removes the accepting route and verifies the retained terminal failure; missing dependencies or an unexercised route fail qualification. Reports and isolated session transcripts stay under .build/model-recovery.
The real answer-correction journey is node tests/model/answers.mjs, with JEDEN_BIN, JEDEN_TEST_SOURCE_REVISION and JEDEN_TEST_STADO. The model is played through Stado's attestation alternative under the run's own HOME, and the journey states each answer: recovered answers a string that never closes, then a final action without text, then a usable final answer; repeated answers the same unclosed string after its correction; limited answers a different unknown action every time until the caller's --max-steps 3. Each pass of a case starts from an empty workspace and session root, so the requests it repeats are the ones already answered. Commands, statuses and exported session events remain under .build/answer-recovery.
Native intake and acceptance inspectors accept their structured JSON directly, inside a Markdown code block, or encoded in the text of a final action. Read-only tool actions still run through the same permission checks. A parsed answer is not evidence of completion: the controller still checks every acceptance requirement and its observation receipts.
Quick start#
Prerequisites: a supported platform or a Rust toolchain for source builds, and a model route. Without a direct provider, Jeden hands each model request to Stado's inference alternatives and needs Stado installed and no Brama credential; jeden token status reports that route in Stado's order, or Stado's declared refusal. A direct provider needs only JEDEN_MODEL_ENDPOINT and, if it requires authentication, either JEDEN_MODEL_KEY or keys stored with jeden token.
Running jeden opens the welcome view. Its first screen can adopt an existing repository in place; the same operation is available as jeden workspace adopt <path>, /setup workspace <path>, and Jeden Desktop Settings. /setup identifies the configured direct route and token availability without rendering the provider URL, or the route Stado's inference alternatives give otherwise. An invalid direct endpoint is shown with its validation cause, not with embedded URL credentials; an unreadable direct endpoint or key is shown as a direct-provider refusal in the picker and checklist. An explicit process key takes precedence without requiring the local token store. Nonsecret router values may be written to ~/.jeden/.env; provider keys live in the private token store or process environment. jeden doctor actively probes configured dependencies and returns a nonzero exit on an unavailable one.
If the environment file becomes unreadable during a running session, /setup names the file and read cause. File-derived values that cannot be established are shown as unknown, not missing: their picker actions cannot offer to overwrite them, and the checklist does not recommend setting them. Values already available to the process and unrelated workspace or preference controls remain available.
A non-comment line of .env that is not KEY=value, or whose quoted value cannot be decoded, refuses startup with the file, zero-based line index and parse cause. Jeden does not silently skip the declaration and continue with a missing route or credential. Process environment takes precedence over file declarations; the file itself is never overwritten by startup.
The registered environment_journey qualification exercises that transition in one process: a readable nonsecret environment file, a real filesystem read refusal, picker and checklist diagnostics without replacement actions, a /setup agent-id <id> write refusal naming the file and cause without replacing it, and recovery to the original values. The runner must supply a fresh isolated HOME inside the checkout’s ignored .build, JEDEN_TEST_SOURCE_REVISION, and the real declared JEDEN_TEST_SETUP_AGENT_ID. Normal credential and router environment variables must be absent so they cannot mask the file. Retain the command, exit status and test output; this filesystem journey does not replace observing the rendered terminal UI.
The journey first compares JEDEN_TEST_SOURCE_REVISION with the clean checkout and the binary’s embedded short revision. A mismatched or dirty candidate is not a qualification result for that source; the runner’s retained output names the refusal.
On a Stado host Jeden names no model service itself: each model request is handed to stado capabilities call inference --consumer jeden --json, which asks the first alternative in Stado's selected order that answers it (Brama, or a statement the operator recorded for that exact request) and returns its answer. An alternative Stado gains later, or an order the operator selects with stado capabilities inference, is used with no change to Jeden. The request's own answer says whether its model is known. When no alternative answers, the refusal is Stado's sentence naming every alternative with its cause and the command that answers the kept request. The model catalog is read the same way (model-catalog), and images and speech through --operation images|speech; Jeden resolves no address of Brama, reads no BRAMA_URL, BRAMA_TOKEN or signing secret for this route and takes no lease. jeden token status (route: stado, with Stado's order or its declared refusal), /setup and jeden doctor (Stado's order, read from stado capabilities inference --json) show the selected route; the real journeys are tests/model/credentials/alternative.mjs, tests/model/routes/route.mjs and tests/alternatives/resolve.mjs.
If a model-backed task ends with a closed connection, inspect that conversation with jeden show <session-id>: its retained failure identifies the actual endpoint or Stado command, route origin and original cause. The same failure is shown in the RPC-backed Desktop conversation. See run diagnostics for the real refusal qualification journey.
On macOS, source builds also need Stado 0.22.0 or later and an available Apple Development or Developer ID Application identity. Build jeden and jeden-sandbox-helper together, then run stado product signing sign --product jeden target/release/jeden target/release/jeden-sandbox-helper. The helper must stay beside the executable. Signing failures stop installation; there is no ad-hoc fallback. The shared contract is Native macOS code signatures.
Stado publishes Jeden as a command-line package, not a running fleet service. Its Darwin archive carries bin/jeden and bin/jeden-sandbox-helper; consumers must install both from the same archive and keep them beside each other. Publication alone is not proof that a consumer can run a task.
Delivery hosts belong to Stado's canonical registry, not Jeden's source. Each native delivery selects target: { "product": "jeden" }; Stado expands the CLI and sandbox-helper deliveries onto every declared target of the matching platform. Read the declaration with stado release destinations show jeden --json. When the catalog still holds the former explicit deliveries, enrollment adopts their exact host set only if every installation operation is preserved; it refuses changed target coverage or dropped operations.
Stado freezes the selected destinations for each release run. A later registry edit does not move a resumed delivery or redelivery. Both the submitter and workers must support object-valued delivery targets before releasing this manifest; an older reader refuses it rather than installing on an arbitrary builder. The delivery destination contract covers declaration changes, migration, retained placement and refusal diagnostics.
The release worker signs the declared native stage before creating the archive. The Darwin recipe supplies the signing certificate and private key through scoped workload credentials and uses the signer's temporary keychain, without a system consent dialog. A missing credential, unusable signing identity or missing helper remains a failed build or run. See Stado release and compatibility for the source-bound publication commands and receipts.
Release builders receive private Git dependencies through the immutable private-cargo-sources input, not through GitHub credentials or sibling checkouts. After changing the private package names, versions or revisions in a committed checkout, run stado release catalog input pin . --name private-cargo-sources --source . --revision HEAD --cargo --json and commit the updated .wisent-release.json. Stado vendors, publishes and pins the input. Changes only to Jeden's own version keep it valid. The shared private Cargo input contract covers publication, desktop controls and refusals.
Quality runs node tests/release/stage.mjs. The native build step is stado product kompilator stage --bin jeden --bin jeden-sandbox-helper: kompilator builds each binary from the locked sources and Stado places it at WISENT_OUTPUT_DIR/<name>, and the recipe archives them as bin/jeden and bin/jeden-sandbox-helper. An absent output directory setting is refused before native compilation. Jeden carries no staging, private-source export or source-replacement code of its own.
The worker's Stado checks the mounted input against the private packages in Cargo.lock and checks its source configuration against its provenance before Cargo starts. Missing input, mismatched packages and unsupported provenance are refusals. Git transport is disabled; Cargo verifies the exported files and preserves the lockfile. Public registry packages still use normal Cargo resolution.
The shared publication journey is tests/release/private-cargo-sources.mjs in Stado. It uses a real committed Cargo source, publishes and reads an immutable archive through isolated local storage, then runs Cargo metadata with mounted sources and no private Git cache. Its records include the source and binary identity, command output, exit statuses and persisted manifest. It does not compile or qualify a native application.
Each native Jeden release runs JEDEN_TEST_SUCCESS_EXIT=0 node tests/release/stage.mjs with the worker's source, source commit, output and private-input environment. It builds and executes the staged CLI, records the helper's staged bytes, and checks missing-output and missing-input refusals without replacing successful artifacts or changing the lockfile. Reports are archived under evidence/release-tests. This is not proof of signing, sandbox execution or a model-backed task.
The exact release version is the SemVer in Cargo.toml. Stado reads it through .wisent-release.json; no run number or provider identity takes part in it. darwin-arm64 and linux-amd64 are the declared promoted outputs. A compilation gate is not evidence that the model-backed completion journey passed: the real contract run and its result remain separate recorded evidence.
The version gate compares the public command vocabulary with released-surface.json using one tool: jeden-tools surface reads the dispatcher and the compiled slash catalogue, jeden-tools versioning decide answers with the fleet's AutoVersion rule itself (the autoversion crate at a pinned revision, held to the rule's shared fixtures), and jeden-tools versioning baseline regenerates the baseline from the newest published release.
This documentation is published from source, and no rendered page is committed. Vercel deploys web/ on every push to main: its build installs the repository's locked Node packages (npm ci --prefix ..) and runs node docs/pages.mjs, which renders web/docs/**/*.html, web/sitemap.xml and web/wisent-components.css from the page sources in web/docs/. A documentation change is therefore published by pushing its source. npm run build:docs renders the same files for a local preview; git ignores them. A failed Vercel build leaves the previous deployment in production.
mkdir -p .build/jeden
WISENT_OUTPUT_DIR="$PWD/.build/jeden" stado product kompilator stage --bin jeden --bin jeden-sandbox-helper
# macOS only, after building:
stado product signing sign --product jeden .build/jeden/jeden .build/jeden/jeden-sandbox-helperjeden run "Respond exactly: OK" --model-only # expected output: OKRun without Brama or Stado#
A user without Brama points Jeden at an OpenAI-compatible provider with JEDEN_MODEL_ENDPOINT, for example https://api.openai.com or a local loopback endpoint. Jeden reads /v1/models and sends chat to /v1/chat/completions. JEDEN_MODEL_KEY takes precedence; otherwise the local token list supplies rotating keys for that endpoint. Direct chat needs no Brama signature and Jeden makes no Skarbiec read.
An explicit JEDEN_MODEL_ENDPOINT turns Brama off. Without it and without Stado on the PATH, Brama is not routed to the process, since Stado's alternatives are the only route to it, and Jeden still works: the first provider in Jeden's token store (jeden token add <label> --endpoint <url>, key on stdin) serves the run, rotating that endpoint's stored keys, and standard error says jeden: Brama is not routed to this process: <cause>; using the OpenAI-compatible provider <endpoint> from Jeden's token store instead, the cause being jeden.alternatives.stado-unstartable. Jeden starts no gateway of its own. The switch is never silent and happens before any model output. With an empty store the run is refused as jeden.model.route.stand-in-absent: finding a provider to stand in for Stado's inference alternatives: <Brama's cause>; no provider stands in for it: Jeden's token store holds no OpenAI-compatible provider, naming the store and whether it exists; a store that cannot be read keeps its own jeden.token.store refusal with a context: line. Where Stado is installed nothing stands in here: which alternative answers is Stado's choice per request. A malformed JEDEN_MODEL_ENDPOINT is refused and never stood in for. An unreadable non-Unicode JEDEN_MODEL_ENDPOINT or JEDEN_MODEL_KEY is named without echoing its bytes by jeden token status, /setup, /model, jeden doctor and Jeden Desktop. A direct provider may omit prices and route promotions, so usage without declared pricing is recorded without catalog-priced cost. Budget admission requires a declared price and token ceilings rather than inventing them; its catalog pricing read uses the same direct-provider token rotation, or Brama's catalog at the route Stado names, before a request is admitted.
Jeden's durable state, memory included, needs no fleet database either. With JEDEN_DATABASE_URL unset, Jeden's own SQLite file ~/.jeden/state.sqlite3 stands in, is created on first use, and standard error says jeden: no fleet database is configured (JEDEN_DATABASE_URL); Jeden's durable state is the local SQLite file <path>. A configured database that does not answer is refused instead of replaced, so state is never split between two stores. The real journeys are tests/model/credentials/stand_in.mjs (Brama not routed, no Stado on PATH, against a real provider kept in the token store, and the refusal with an empty store), tests/model/routes/route.mjs (the refused direct routes and the empty store) and tests/context/independent.mjs (memory on the SQLite stand-in in an isolated home).
An invalid direct endpoint is a refused direct route, not permission to try Brama instead. jeden token status --json reports keySource: refused, a null endpoint and routeRefusal; catalog and chat calls stop before transport with that cause.
Brama's any and any-vision-capable virtual routes are not provider model IDs. The direct picker shows concrete IDs; a direct run or jeden doctor naming a Brama virtual route refuses rather than treating it as a usable provider model.
/rebuild in an interactive session is jeden.rebuild (jeden errors show jeden.rebuild, tests/rebuild/interactive.mjs). It has Stado build Jeden from the workspace's Cargo.toml with kompilator (stado product kompilator --manifest-path <workspace>/Cargo.toml stage --bin jeden, no Cargo) into the workspace's .build/rebuild, signs it, checks it answers jeden <version> and moves the session into it. On macOS it asks Stado for the running code identity (stado product signing inspect --json) and has Stado sign the new build; with JEDEN_CODESIGN_IDENTITY set it signs with /usr/bin/codesign --force --sign <identity> and asks Stado nothing. Each refusal names its step: a word after the command (argument-unexpected), no Cargo.toml (manifest-missing), a .build/rebuild that cannot be made (output-uncreatable), Stado that cannot start to build (builder-unstartable) or to sign (stado-unstartable, fix: install Stado or set JEDEN_CODESIGN_IDENTITY), a failed build (build-failed; the session goes on in the running build), a signer that refuses, and a build that cannot start, refuses --version or answers as another program. In a one-shot jeden run it is jeden.modes.interactive-only.
export JEDEN_MODEL_ENDPOINT=https://api.openai.com
# PROVIDER_KEY must already contain your provider key.
printf '%s\n' "$PROVIDER_KEY" | jeden token add personal --endpoint https://api.openai.com
jeden token list
jeden run "Respond exactly: OK" --model gpt-4o --model-onlyRun a named VS Code task on macOS#
On a configured Wisent workstation the installed Jeden hands its model requests to Stado's inference alternatives and needs no Brama credential in its environment. The reusable task in scripts/vscode-tasks.json runs a disk diagnosis in a dedicated integrated terminal, without typing into another terminal's prompt or changing the default model.
From the root of a Jeden checkout, run the command below only when VS Code has no user task file. If that file already exists, preserve it and add this task to its tasks array instead. Choose Terminal → Run Task… → Jeden: diagnoza dysku bez zmian; the named terminal retains the command and final exit status, and only one instance can run at a time.
The task asks for paths, sizes, growth causes and APFS accounting without deletion, compilation, configuration changes or consent prompts. It grants command execution, not a filesystem sandbox; these restrictions are part of the diagnosis prompt. A Brama that does not serve the run is stood in for only by the provider in Jeden's token store, as described above, and never by a new login.
ln -s "$PWD/scripts/vscode-tasks.json" \
"$HOME/Library/Application Support/Code/User/tasks.json"Current scope#
The private milestone includes:
- interactive terminal and one-shot
jeden runmodes; - autonomous outcome pursuit through
jeden pursue, with source-grounded contracts, independent reviews, and durable receipts; - session transcripts and artifacts under
~/.jeden/sessions/; - model routing through Stado's inference alternatives (
stado capabilities call inference --consumer jeden), which present what they need, so Jeden reads no Brama bearer or signing secret for a model request, or through an OpenAI-compatible provider named byJEDEN_MODEL_ENDPOINT; - model selection in one order every surface reads (the run,
/model,/setup,/roles, the advisor label,/doctorand the Brama health probe):--modelor the session's/modelchoice, thenJEDEN_MODELfor one run, then the configuredmodel; a blank value selects nothing, an unreadableJEDEN_MODELis refused naming it, and no other variable (such asMODEL) is read; - goal-lifecycle classification of each prompt by the lifecycle model Brama serves under the alias
JEDEN_LIFECYCLE_MODEL_ALIASnames, signed like every other model call; without the alias there is no classifier. Its output ceiling comes from that alias's catalog entry, not a separate classifier token budget. An unread catalog or undeclared ceiling is named on stderr and adds no local ceiling; a readable catalog refuses an unknown, unavailable or unrepresentable route declaration. A refused classifier call is recorded in the session ledger asgoal_lifecycle_refusedwith its actual reason. A started goal is titled by<transcript-lake> goal title --stdin --json, run as thetranscriptsalternativestado capabilities resolve transcripts --consumer jedennames, when this host offers one (Stado installed and one answering), otherwise by the prompt's first line that holds text; a transcripts alternative Stado cannot name as asked, one that cannot start, exits unsuccessfully or answers no goal, and a prompt with no text, recordgoal_lifecycle_refusedwith the command and cause and start no goal.jeden pursuewith commands allowed reads its preference evidence from the same alternative, and refuses with itsjeden.alternativescause when Stado cannot name one as asked; - jailed filesystem, document, archive, image, SQLite, search, Git, process, evaluation, URL, artifact, memory, todo, delegation, and MCP tools;
- guarded file mutations using the digest or snapshot tag returned by
read_file; - custom JavaScript tools, project and user lifecycle hooks, and native
.jedenconfiguration paths; - transactional
jeden updatethat verifies a signed release manifest against the binary's embedded trust roots, checks artifact and provenance evidence, and rolls back to the journaled last-known-good binary on failure; - interactive approval for writes and commands unless explicitly enabled.