FAQ

Is LADR free to use?

Authoring ladders in Foundry is free. Running ladders costs whatever your configured LLM providers charge (you bring your own keys; BYOK). Publishing to the public library is free. The Redeo platform takes a cut only on paid ladders.

Do I need to install anything?

No. Author in Foundry (browser), call via curl/any HTTP client. A CLI is planned but not required for any workflow today.

What models work with LADR?

Any model available through a configured provider (OpenAI, Anthropic, DeepInfra, etc.). The model is chosen by the caller at request time and must be allowed by the ladder's allowedTargets policy.

What programming languages can call a ladder?

Any. A ladder is just an OpenAI-compatible HTTP endpoint. Existing OpenAI client libraries (Python, JS, Go, Rust, Java, etc.) work with one URL change.

Do I need to know LADR to use a ladder?

No. Callers treat a ladder as a drop-in URL swap for OpenAI. The strategy runs server-side; the caller just sees a normal chat completion response. LADR knowledge is only required to author ladders.

Is LADR Turing-complete?

Yes, by design. LADR can express unbounded loops, recursion, conditional branching, and runtime self-modification via dynamic steps. Termination is not statically guaranteed (halting problem); instead, the engine enforces hard runtime ceilings (spend cap, hop ceiling, LLM-call ceiling, recursion depth). This is what makes untrusted published ladders safe to run.

Why YAML and not JSON / TOML / a custom DSL?

YAML is the most readable format for the kinds of nested structured configs ladders require (steps, fields, schemas). JSON works too; Foundry's editor and the API speak JSON natively; YAML is just the author-facing surface. The engine accepts both.

Can a ladder call another ladder?

Yes; via cross-ladder jumps (then: { jump: { ladderId: "@author/name" } }) or via recursion (recursion: { maxDepth: N } on a step). Cross-ladder jumps are tail-calls (the current execution terminates and the target ladder takes over); recursion is a parent/child nesting.

What happens if a ladder fails validation?

Foundry shows the error inline at save time. The API's POST /v1/validate endpoint returns the structured error list. A ladder that fails validation cannot be published or executed.

Can I version a ladder?

Yes. Every save creates a new version. Callers can pin to a specific version (@v3) or accept latest. Username renames create permanent redirects so existing references keep working forever (GitHub model).

Are slates per-user or shared?

Per-user by default. User A's calls read and write to their own slate. Cross-user sharing is a planned feature.

How big can a slate get?

Each folder declares its own tokenLimit. When a write would exceed it, the evictionPolicy runs (FIFO / LRU / reject). Total slate size = sum of folder budgets. There is currently no platform-wide slate-size cap, but slate content gets rendered into prompts; so the practical limit is your model's context window.

Can I edit a slate by hand?

Currently, no — slates live in Redis / DB and are edited via the ladder. A planned local-first mode would materialize slates as .md files with YAML frontmatter (an Obsidian-compatible vault): edit by hand, sync to cloud, diff in git.

Do slates work with vector search / embeddings?

Not yet. A planned update adds an auto-maintained embedding system metatag and a semantic-similarity retrieve: mode. The slate grammar is unchanged; the new mode slots in behind the existing interface.

Can two ladders share a slate?

Not directly today; slates are scoped to the ladder. To share memory, use cross-ladder jumps (then: { jump: { ladderId: "@you/other" } }) or recursion. Cross-ladder slate sharing is planned.

How do I cap the cost of a ladder?

Set executionBudget.maxSpend to a dollar amount per call. The engine hard-kills the execution the moment cumulative LLM spend crosses the cap, returning the best-so-far output. Platform max is $50/call; default is $5/call.

Can a malicious published ladder runaway-loop?

It can loop, but every loop iteration costs money. The spend cap is the hard kill. Even a ladder that tries to loop forever will terminate when it hits the cap. The runtime caps — not grammar restrictions — are the safety model.

What does a caller see when a ceiling is hit?

A normal completion response with the best-so-far output. The trace shows the ladder terminated with a best-so-far output. This is informational, not an error; the ladder did as much as it could within its budget.

Can I see how much a call cost?

Yes; the response's usage field reports total tokens consumed across all LLM calls in the execution. Per-step cost breakdown is visible in Studio's timeline.

How do I prevent a caller from setting knobs that explode cost?

Knobs are clamped to their declared min/max at runtime. Also set a conservative executionBudget; even a caller who sets branches: 9 won't blow past your maxSpend cap.

Can I self-host the engine?

Yes. The engine, gateway, and API are AGPL-3. Self-host to run ladders on your own infrastructure, with your own provider keys. The Redeo Cloud (marketplace, billing, cloud sync) is the proprietary layer; self-hosters can run ladders but can't easily replicate the marketplace.

Is there an SDK?

Not a separate SDK; the OpenAI client libraries ARE the SDK. Any OpenAI-compatible client in any language calls ladders natively. For ladder authoring, the API surface is the Foundry visual editor + the POST /v1/validate endpoint for programmatic validation.

Can ladders be private?

Yes. Visibility tiers: local (self-hosted only), hosted-private (callable via API, not listed), public-free (AGPL, full config disclosed), public-paid (creator-priced), enterprise-local-licensed (deployed to customer sites).

What's the latency profile of a ladder?

A ladder's wall-clock latency = (number of LLM calls) × (per-call latency of the chosen model) + small engine overhead. A 5-node Tree-of-Thoughts with synthesis is roughly 6 LLM-rounds deep. With GPT-4o, expect 10–30 seconds end-to-end. Ladders are not designed for sub-second request paths.

What's the difference between Redeo, LADR, Foundry, Studio, and the Library?

• Redeo; the company / platform.
• LADR; the language ladders are written in.
• Foundry; where you build ladders (visual editor).
• Studio; where you use ladders (consumer UX with live timeline).
• Library; where you discover published ladders (public directory).

How do I make a ladder that works for N minutes?

Pass a timezone field on the API call (IANA name like "America/New_York"), then read input.systemTime (UTC, always present) or input.localTime (in your declared timezone) from any field. The LLM does the arithmetic:

- id: pace_check
  fields:
    - { name: Now, type: text, from: input.systemTime }
  systemPrompt: "Current time: {{Now}}. Output STOP if more than 30 minutes have elapsed since start, else CONTINUE."
  if: { equals: "STOP", then: { jump: { stepId: finalize } }, else: continue }

The engine auto-injects input.systemTime on every instance (UTC ISO 8601). It auto-injects input.localTime and input.timezone only when the API caller supplied a timezone parameter in the request body. Recursion and cross-ladder handoffs refresh these at child creation so the child sees its own moment, not the parent's.

Why no wall-clock ceiling?

Time is exposed as data, not as a budget. Authors build time-aware behavior via fields + gates + jumps; the existing spend/hop/LLM-call ceilings bound total work. If a true wall-clock cap is needed later, it would slot into executionBudget as maxSeconds — but the visibility-first design covers the common cases without it.

See also: Fields > Fallback sources for the full list of auto-injected input keys and how fallback: lets a field degrade gracefully when its primary source misses.