About Redeo

Your model knows more than it can surface in a single pass. Ask GPT a hard question and you get one answer — the first thing that comes to mind. But the model has richer knowledge, better reasoning, and more nuance buried inside it. The problem isn't the model. The problem is that we ask models to answer in one shot.

Redeo fixes this by making search strategies first-class objects — not hardcoded logic buried in application code, but declarative configs you can write, share, version, and call from anything.

The Problem with One-Shot Generation

When you send a prompt to an LLM, you get back whatever the model produces on its first pass. No exploration, no evaluation, no second guessing. Sometimes that's fine. But for hard questions — nuanced analysis, complex reasoning, creative tasks — one pass leaves better answers on the table.

Research has shown this repeatedly. Tree of Thoughts. Chain-of-Thought. Self-consistency sampling. Debate. Recursive refinement. These strategies all share the same insight: if you let a model explore multiple paths, evaluate what it finds, prune the bad ones, and iterate on the survivors, you get significantly better results than one-shot generation.

The problem isn't discovering new strategies — it's implementing them. Each one requires custom orchestration code, state management, error handling, and observability. Every team reinvents it. Most don't bother.

LukiScript

LukiScript is a declarative DSL for describing search strategies. Instead of writing orchestration code, you write roughly 30 lines of YAML. You define steps (execution units), fields (data flow between steps), knobs (runtime controls the caller can adjust), loops (iteration over the full step sequence), gates (branch pruning via output matching), recursion (spawning child executions from a step's output), and groups (running sibling steps in parallel).

Redeo handles execution, state, and observability. You describe what the search should do. Redeo handles how.

Every LukiScript config is validated before it runs — bad references, invalid field shapes, and constraint violations are caught before a single LLM call is made. The config is the single source of truth: it defines the strategy, the data flow, the controls, and the output.

Stilts

A stilt is a search strategy written in LukiScript — saved, versioned, and shareable. The name comes from Wittgenstein's childhood nickname. The idea: language defines the boundaries of thought, and LukiScript gives you a language to define how that thought unfolds.

Every stilt exposes itself as an OpenAI-compatible API endpoint. Anything that talks to OpenAI can talk to a stilt — swap the base URL, pass a stilt ID, and your existing application gets better answers. No code changes. The caller never needs to know what's happening behind the scenes.

You set visibility: private (only you), unlisted (anyone with the link), or public (visible in the library). The platform manages versioning, authorship, and routing.

Foundry

Foundry is where you build. Use the visual step editor to add steps, define fields, configure knobs, set system prompts, and wire up data flow — or paste raw YAML directly and let Foundry parse and validate it.

When you run a stilt in Foundry, each step appears as a stage card showing the assembled prompt and the LLM's output. You can watch the search unfold in real-time, inspect intermediate outputs at every stage, drill into recursion depths, and debug issues without reading logs. Knob controls let you adjust parameters and re-run to see how the strategy responds.

Save your work as a stilt. Edit, re-run, iterate. Publish to the library when you're ready.

Studio

Studio is where you use stilts. It's the consumer experience — first-class observability for running and monitoring search strategies. Send a message, watch the live timeline render each step as it executes, click any node to inspect its output, and see the final answer emerge from the search.

No config editing. No building. Just clean, real-time visibility into how a stilt processes your question. Studio makes search strategies accessible to anyone — you don't need to know LukiScript to benefit from a well-designed stilt.

The Bigger Picture

Redeo makes search strategies into first-class objects. Write once in LukiScript, share as a stilt, call from anything. The model doesn't change. How you use it does.

This isn't about training bigger models or collecting more data. It's about how you let models use what they already know. A small model running a well-designed search strategy can surface answers that a large model misses in one shot. The intelligence was always there — it just needed better exploration to find it.

We believe reasoning improves through a simple loop: try, reflect, adjust. Redeo applies this loop at inference time, and makes it programmable.