Overview
Recursive.org is a project maintained by Cass Wigley that builds on an ecosystem of interconnected applications designed around a single principle:
information becomes intelligent through recursion.
Each recursive application follows a simple pattern: the user uploads or enters information, which is then interpreted and transformed into a structured format defined by a specific JSON schema. This schema establishes the data model used by a complex UI to generate rich, functional artifacts for planning, mapping, writing, designing, or visualizing. The language model returns its interpretation as data that validates against this schema, allowing it to be immediately expressed within the UI or consumed by the application.
The user can then immediately interact with the returned artifacts—adjusting timelines, adding or deleting nodes in a mind map, or tweaking a wireframe layout. Alternatively, they can interact with the layout through chat commands, directly discussing the artifact with the LLM to request changes via ChatOps. In doing so, they delegate the “busy work” of setting values, moving elements, and performing repetitive adjustments to the LLM, which can execute these operations instantly.
In doing so, each component participates in a shared recursive loop that is both intricate and dynamic.
These applications do not merely exchange data in a one-way manner; instead, they engage in a co-evolutionary process that enhances and transforms the information they handle. Every interaction, prompt, and edit contributes to this ongoing cycle of transformation, where structured information continuously refines itself through repeated translation across various tools, schemas, and the collaborative efforts of humans. This process is not a linear progression but rather a complex interplay of ideas and data that evolves over time. Rather than existing as a mere stack of independent applications, Recursive emerges as a living medium — a vibrant and dynamic environment that fosters thinking, making, and organising in concert with artificial intelligence. In this ecosystem, each application enriches the others, creating a synergistic effect that amplifies creativity and productivity. The result is a seamless integration of technology and human ingenuity, where the boundaries between different forms of expression and tools blur, leading to innovative outcomes that are greater than the sum of their parts.
1. The Local Loop: From Prompt to Structure to Interface
Every Recursive app begins with a conversation.
A user expresses intent — a plan, a schema, a diagram, a request — in natural language. The LLM interprets this and generates a structured representation (e.g., JSON, YAML, or a custom domain schema). That structure becomes the substrate for an interface: a visual or functional form that can be edited directly.
The user then modifies, extends, or recontextualises the result — adjusting parameters, re-ordering nodes, redefining fields. These edits are written back into the schema, which in turn informs the next AI prompt.
Each iteration refines both the structure and the interpretation, leading to a more nuanced understanding of the underlying concepts. This process exemplifies recursion at the level of interaction: the model generates a framework of structure, which the interface then reifies, or makes tangible, allowing users to engage with it in a meaningful way. As users interact with this structure, they re-author it based on their unique perspectives and intentions, thereby creating a dynamic loop of continuous alignment between their original intentions and the representations they encounter. This ongoing cycle not only enhances the clarity and effectiveness of communication but also fosters a deeper connection between the user and the content, ultimately enriching the overall experience.
2. The Inter-App Loop: Translation Across Schemas
Each Recursive app has its own schema — its native grammar of meaning:
- Re-Plan expresses goals, dependencies, and timelines.
- Re-Map organises conceptual hierarchies and relationships.
- Re-Sequence structures ordered processes or musical stems.
- Re-Flow, Re-Work, Re-Tarot, and others each hold their own ontologies.
But the deeper power of the system lies in the translation layer between them.
A timeline can inform a brief; a mindmap can generate a plan; a setlist can reappear as a schedule. Each app can send and receive structured data that is interpreted in terms of the receiving schema — a kind of semantic relay.
This circulation produces recursive alignment: schemas evolve not through central enforcement but through repeated cross-translation. Over time, shared vocabularies and patterns of interoperability emerge organically, guided by actual use rather than imposed standards.
3. The Meta-Loop: Context as a Living Record
All interactions — prompts, edits, schema states, generated artefacts — are recorded as evolving context graphs.
Rather than a static context window, each project maintains a temporal trace of its recursive history. Every iteration becomes a node in a living dataset that remembers how an idea has changed across time and tools.
An “idea,” in this framework, is not a single artifact. It’s the trajectory of transformations linking multiple representations — a plan, a timeline, a mindmap, a document — all co-evolving as parts of a single recursive process.
This enables semantic memory: systems can learn from the evolution of their own outputs, re-entering prior states to generate informed continuations or alternate futures. Recursion thus becomes both the creative engine and the record of creativity.
4. The Systemic Loop: Continuous Co-Development
When these loops interlock — human ↔ AI, app ↔ app, iteration ↔ context — the result is a self-improving ecosystem.
Each cycle enhances interoperability, clarity, and creative resolution.
- Prompts become more semantically precise.
- Schemas become more expressive.
- Interfaces become more adaptive to context.
The Recursive ecosystem functions as a distributed co-intelligence network, where design, planning, and reflection form a continuous feedback system. Ideas are never static; they are alive in translation, always in the process of refining themselves through the act of being shared.