You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
TODO: Write content for **Carpenter (Autoregressive DSLM)**.
8
+
9
+
-**Job**: Precisely implement each Actor within Directors. Takes the visually sketched "dreams" and translates them into executable, correct code. It rigorously validates syntax, ensures type correctness, and guarantees that every Actor compiles, passes tests, and integrates cleanly into the Cond8 infrastructure.
10
+
-**Style**: Methodical, strict, and precise. If the Dreamer envisions something creative like `StoreActors.Compactify('SecretKey')`, the Carpenter ensures this Actor is accurately implemented, throwing errors immediately if anything doesn't match specifications.
11
+
-**Why Autoregressive?**: The Carpenter’s autoregressive nature enforces strict correctness, bridging the gap between imaginative visual structures and robust, production-ready code.
TODO: Write content for **Dreamer (Diffusion DSLM)**.
8
+
9
+
-**Job**: Visually sketch and maintain Cond8 Directors as structured, image-like compositions. Rather than worrying about exact syntax or precise logic, the Dreamer treats each Director as a cohesive visual structure, like a blueprint or pixel art, clearly bounded by initialization (`init`) at the top and finalization (`fin`) at the bottom.
10
+
-**Style**: Loose, intuitive, and creative. It excels at rapidly visualizing pipelines and imagining new roles or actors—even those that don't yet exist. The Dreamer doesn’t require token-by-token precision; instead, it ensures that the overall visual integrity and structure remain coherent across hundreds of Directors simultaneously.
11
+
-**Why Visual?**: Viewing Directors as images leverages the natural strengths of Diffusion models, enabling efficient maintenance and exploration of large-scale, structured codebases without overwhelming VRAM constraints.
Cond8 is, at its core, a pipeline—a sequence of functions executed one after another. In Cond8, we call these functions *Actors*, and the entire pipeline is called a *Director*. Directors are fully composable, meaning you can seamlessly embed Directors within other Directors, allowing you to build sophisticated workflows from simple, reusable parts. This structured approach empowers Domain-Specific Small Language Models (DSLMs) to clearly focus on coding just one Actor at a time. Each Actor is strictly limited—it must only **get** something, **do** something with it, and **set** something back. This straightforward yet powerful restriction makes Cond8 uniquely effective, providing DSLMs with a predictable and manageable framework to reliably generate correct code. Because each Actor has a clearly defined expected output, Cond8 can automatically retry or regenerate Actors until they pass their tests.
3
+
**Cond8**is a framework for building AI-generated workflows that are reliable, testable, and step-by-step.
4
4
5
-
What makes Cond8 different isn’t polish — it’s that its core contracts with DSLMs are built into the infrastructure. If those break, the entire system fails by design. Cond8 isn’t just automation — it’s a deliberately constructed execution environment. Everything from director composition to actor behavior is formalized in code, so DSLMs don’t guess — they operate within strict, testable boundaries. That same structure also makes it easier for you, the human developer, to reason about complex systems and build software that doesn’t just work — it holds.
5
+
Pronounced **Conduit** — with a nod to the French word for _eight_ — Cond8 works like a pipeline: a sequence of small, composable steps. Each step is called an **Actor**, and a full workflow is called a **Director**. Every Actor follows a strict contract: it gets something, does something, and sets the result.
### **Q1: What exactly does the `HelloDirector` example do?**
70
-
**A:** It sets up a web endpoint (`GET /hello/:name`) that returns an HTML page greeting visitors by their capitalized name. For example, accessing `/hello/john-doe` displays "Hello, John Doe!".
71
-
72
-
### **Q2: What is happening inside each Actor in this Director?**
73
-
**A:** Each Actor follows the strict Cond8 pattern of **Get → Do → Set**:
74
-
75
-
1.**ParamsGuard**: Ensures the URL param `:name` is a valid string.
76
-
2.**CoreActors.Get.String & Do**: Fetches the param and capitalizes it.
77
-
3.**VHXActors.Title**: Sets the browser tab title.
78
-
4.**VHXActors.Template**: Creates HTML content using JSX.
79
-
5.**VHXActors.WrapHtml**: Wraps content into a complete HTML document.
80
-
81
-
### **Q3: What's the purpose of the `Conduit` in `init(...)`?**
82
-
**A:** The **Conduit** is a shared state space allowing Actors to read, transform, and store data safely. Each Actor interacts exclusively through it, ensuring Actors remain isolated and easy to test or regenerate.
83
-
84
-
### **Q4: What does the `.fin(...)` method do at the end of the Director?**
85
-
**A:** It finalizes the Director by defining the specific output—here, the final rendered HTML. After calling `.fin(...)`, the Director becomes executable and ready to deploy as a web route handler.
86
-
87
-
### **Q5: How does Cond8 handle errors within the `HelloDirector`?**
88
-
**A:** If an Actor fails, Cond8 automatically halts execution. It then retries or regenerates the faulty Actor using detailed runtime insights, ensuring reliability and correctness through its built-in auto-fixing mechanism.
89
-
90
-
---
91
-
92
-
## Domain-Specific Small Language Models (DSLMs)
93
-
94
-
Domain-Specific Small Language Models (DSLMs) are compact language models specially fine-tuned to interact precisely with the specific services provided by the Cond8 Engine. Cond8 relies on two complementary types of DSLMs, each trained for a distinct purpose: creative director prompt writing, and precise, restrictive actor script writing.
95
-
96
-
1.**Diffusion DSLM – The Dreamer**
97
-
-**Job**: Visually sketch and maintain Cond8 Directors as structured, image-like compositions. Rather than worrying about exact syntax or precise logic, the Dreamer treats each Director as a cohesive visual structure, like a blueprint or pixel art, clearly bounded by initialization (`init`) at the top and finalization (`fin`) at the bottom.
98
-
-**Style**: Loose, intuitive, and creative. It excels at rapidly visualizing pipelines and imagining new roles or actors—even those that don't yet exist. The Dreamer doesn’t require token-by-token precision; instead, it ensures that the overall visual integrity and structure remain coherent across hundreds of Directors simultaneously.
99
-
-**Why Visual?**: Viewing Directors as images leverages the natural strengths of Diffusion models, enabling efficient maintenance and exploration of large-scale, structured codebases without overwhelming VRAM constraints.
100
-
101
-
2.**Autoregressive DSLM – The Carpenter**
102
-
-**Job**: Precisely implement each Actor within Directors. Takes the visually sketched "dreams" and translates them into executable, correct code. It rigorously validates syntax, ensures type correctness, and guarantees that every Actor compiles, passes tests, and integrates cleanly into the Cond8 infrastructure.
103
-
-**Style**: Methodical, strict, and precise. If the Dreamer envisions something creative like `StoreActors.Compactify('SecretKey')`, the Carpenter ensures this Actor is accurately implemented, throwing errors immediately if anything doesn't match specifications.
104
-
-**Why Autoregressive?**: The Carpenter’s autoregressive nature enforces strict correctness, bridging the gap between imaginative visual structures and robust, production-ready code.
105
-
106
-
---
107
-
108
-
**Synergy between Dreamer and Carpenter**:
109
-
110
-
By having the Diffusion DSLM handle the visual, structural integrity of large codebases (like images), and the Autoregressive DSLM meticulously ensuring correctness at the actor implementation level, Cond8 achieves a powerful combination of creativity and reliability:
111
-
112
-
-**Dreamer (Diffusion)**: Efficiently manages hundreds of Directors visually.
113
-
-**Carpenter (Autoregressive)**: Guarantees correctness and precision within each Director.
114
-
115
-
Together, they ensure that Cond8 remains flexible, innovative, and robust.
7
+
Because it's linear, Cond8 can model any problem with a clear input and output — no matter how complex — by breaking it down into simple, deterministic steps. This structure makes Cond8 easy to reason about, safe for LLMs to write, and perfect for automatic recovery when something fails. Whether you're orchestrating a backend, building tools, or guiding local models, Cond8 turns your problem into a workflow that holds.
116
8
117
-
---
118
-
119
-
### What about Prompting?
120
-
121
-
Prompting in Cond8 is dynamic and adaptive, driven by runtime insights captured by the Cond8 Recorder. The Recorder meticulously tracks every meaningful interaction—each method call within the Conduit, as well as lifecycle events between directors and actors. Cond8’s prompt infrastructure can then intelligently filter and process this rich, recorded data, removing noise to provide clean, relevant prompts uniquely tailored to each Actor at runtime.
122
-
123
-
This powerful system also supports Cond8’s automatic error-fixing capability (AUTO_ERROR_FIX). When an error occurs, it immediately becomes integrated into the Actor’s next prompt, providing the Imperative DSLM with clear, actionable context. This feedback loop continuously enhances precision, reliability, and the model’s ability to handle edge cases—all seamlessly at runtime.
124
-
125
-
---
126
-
127
-
## Procedural Lambda Execution Engine
9
+
What makes Cond8 different isn’t polish — it’s structure. Its core contracts with small language models are embedded directly into the execution environment. And if one of those contracts breaks, the system doesn’t quietly fail — it **pushes back** and forces a retry.
128
10
129
-
Cond8 runs on a specialized execution engine designed to maximize clarity, reliability, and performance. Here’s how each part contributes to the overall experience:
11
+
Cond8 doesn’t prevent LLMs from hallucinating — it **embraces** it. If a model invents a function that doesn’t exist, Cond8 treats that as a new workflow to scaffold. Hallucinated Actors become recursive stubs, validated in isolation until they work.
130
12
131
-
-**Procedural**: Actors are executed sequentially, one after another. This linear progression ensures predictable interactions and easy debugging, as every Actor clearly builds upon the previous Actor’s results.
132
-
133
-
-**Lambda**: Directors can be represented as compositions of pure functions, following principles from lambda calculus. Because of this purity and mathematical rigor, Cond8 can aggressively optimize Directors—automatically reducing them to their minimal computational footprint. This optimization process is what we call **Director Shaking**: turning declarative, expressive pipelines into tightly optimized computations.
134
-
135
-
-**Execution**: Each Actor receives careful attention during execution. Cond8 enforces built-in assertions and constraints, making sure that Actors behave as intended. If an assertion fails, Cond8 invokes a specialized imperative DSLM—an error-handling Actor—trained explicitly to detect, diagnose, and even automatically patch logic errors and edge cases.
136
-
137
-
-**Engine**: All these layers come together in Cond8’s robust and highly orchestrated runtime environment. This engine integrates procedural sequencing, lambda calculus-inspired optimizations, automated self-healing mechanisms, and robust actor lifecycle management, creating a dependable and performant execution platform for your DSLM-generated code.
13
+
This turns guesswork into forward motion. Every Actor still runs inside a formalized, testable pipeline where success is explicit and failure is visible — but the system is designed to correct itself, step by step, until even a hallucination becomes code that holds. The same structure that disciplines the model also helps you build software you can trust.
138
14
139
15
---
140
16
141
17
## Core Restrictions
142
18
19
+
These core restrictions are made for the Small Language Model to write code in a more predictable and testable way.
20
+
143
21
### 1. **Directors (The Pipeline)**
22
+
144
23
The first core restriction prevents DSLMs from attempting to generate an entire codebase at once. Instead, DSLMs write a linear pipeline: a clearly defined series of input/output transformations. Although simple in structure, pipelines turn out to be remarkably expressive. Each Director becomes a powerful, declarative interface for computation—easy to reason about, easy to test, and easy to maintain.
145
24
146
25
### 2. **The Virtual Conduit**
26
+
147
27
The Conduit is the central hub of every Director. Actors aren't allowed to communicate directly with each other; instead, they interact exclusively with the Conduit. This isolation greatly simplifies testing, enhances predictability, and makes individual Actors easy to regenerate if something goes wrong.
148
28
149
29
Internally, a Conduit consists of **layers of services**, ranging from straightforward local key-value storage to complex asynchronous communication. Each layer is defined by a **Blueprint**, an abstract class you can extend and customize as needed.
@@ -153,6 +33,7 @@ For example, the `StrictKVBlueprint` provides standard key-value methods like `g
153
33
If strict isn't the right fit, you can always extend from `EmptyBlueprint` or define your own completely custom Blueprint—Cond8 provides structure without limiting flexibility.
154
34
155
35
### 3. **Roles**
36
+
156
37
Roles can be summarized simply as **prompt infrastructure**. When creating Directors, you might sometimes need to write intentional scaffolding—even if it feels verbose or redundant—to help clearly and declaratively describe your logic. This structured scaffolding guides the Director-writing DSLM, allowing it to craft more creative and meaningful Actor prompts.
157
38
158
-
Whatever the Director writer DSLM specifies, the imperative Actor-writer DSLM must respect and follow closely. Actor prompts are always structured clearly as *Get → Do → Set*. A little hallucination from the Director writer DSLM is acceptable because Cond8’s CLI can automatically generate any necessary scaffolding code to bring imagined or hallucinated Actors into reality. Once scaffolded, the imperative DSLM takes over and meticulously implements the Actor’s actual logic—bringing the Director to life.
39
+
Whatever the Director writer DSLM specifies, the imperative Actor-writer DSLM must respect and follow closely. Actor prompts are always structured clearly as _Get → Do → Set_. A little hallucination from the Director writer DSLM is acceptable because Cond8’s CLI can automatically generate any necessary scaffolding code to bring imagined or hallucinated Actors into reality. Once scaffolded, the imperative DSLM takes over and meticulously implements the Actor’s actual logic—bringing the Director to life.
0 commit comments