diff --git a/.github/workflows/jekyll-build.yml b/.github/workflows/jekyll-build.yml new file mode 100644 index 0000000..7571038 --- /dev/null +++ b/.github/workflows/jekyll-build.yml @@ -0,0 +1,33 @@ +name: Jekyll Build + +on: + pull_request: + push: + branches: [ main ] + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Set up Ruby + uses: ruby/setup-ruby@v1 + with: + ruby-version: '3.2' + + - name: Install dependencies + run: | + gem install bundler + bundle config set --local path 'vendor/bundle' + bundle install --jobs 4 --retry 3 + + - name: Build site + run: bundle exec jekyll build --trace + + - name: Upload site (artifact) + uses: actions/upload-artifact@v4 + with: + name: site + path: _site diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md new file mode 100644 index 0000000..e24fd48 --- /dev/null +++ b/ARCHITECTURE.md @@ -0,0 +1,30 @@ +# Architecture Notes — Recursion Lab + +This file distills a short Architect Guide for module authors who want to design and manage whole projects. + +Principles +- Encapsulate intent: module boundaries should reflect responsibilities and invariants, not only file layout. +- Standardize interfaces: use explicit, stable contracts (schemas or API specs). +- Observability from the start: logs, traces, and metrics make integration problems visible. +- Design for graceful failure: define how modules degrade and recover. +- Evolve safely: version contracts and provide deprecation paths. + +Quick checklist +- One-line ownership for each module (who owns what). +- Explicit contract for each integration (inputs, outputs, errors). +- Failure modes documented and practiced. +- Integration tests in CI (contract tests and a small end-to-end smoke test). +- Observability: structured logs + a couple of business metrics for key flows. + +Mini example (blog) +- Content API owns canonical content and emits `content.updated` events. +- Admin UI talks to Content API synchronously for editing flows. +- Search service subscribes to events to index content asynchronously. +- CDN serves static builds; preview mode reads content directly for staging. + +Practical next steps (minimal edits you can do now) +- Add one-sentence ownership lines to module READMEs. +- Add a contract checklist entry to PR templates (if you have them). +- Ensure CI runs the Jekyll build (already present) and add a smoke test for a public route. + +If you want, I can convert this into a more detailed `ARCHITECTURE.md` with diagrams, or add a small PR template and a README checklist. For now this is kept minimal so you can add your content later. diff --git a/README.md b/README.md index 90b0d3d..5f8c814 100644 --- a/README.md +++ b/README.md @@ -177,3 +177,27 @@ The color schemes and fonts can also be customized through scss, by editing the - Base theme sparrow by [lingxz](https://github.com/lingxz/sparrow) - Icon made by [Freepik](https://www.freepik.com/) from www.flaticon.com + +## Local development + +To preview the site locally you can use Bundler and Jekyll. From the repository root run: + +```bash +# install gems +bundle install + +# build the site and serve locally +bundle exec jekyll serve --livereload +``` + +Open http://127.0.0.1:4000 in your browser to preview changes. When creating posts, add files to `_posts/` with a filename like `YYYY-MM-DD-title.md` and appropriate front matter. + +See `_qa/pagination-snippet.txt` for a quick build verification note I added earlier. + +### Drafts + +Place in-progress posts in the `_drafts/` folder (no date in filename). To preview drafts locally, run: + +```bash +bundle exec jekyll serve --drafts --livereload +``` diff --git a/_drafts/case-study-emergent-recursive-cognition.md b/_drafts/case-study-emergent-recursive-cognition.md new file mode 100644 index 0000000..ffc3648 --- /dev/null +++ b/_drafts/case-study-emergent-recursive-cognition.md @@ -0,0 +1,16 @@ +--- +title: "Case Study: Emergent Recursive Cognition" +author: Recursion Lab +tags: [case-study, emergence] +--- + +Reported experiments (e.g., OnToLogic V1.0) where recursive loops produced unexpected behaviors. + +- What worked / what didn’t +- Lessons and reproducible setups + +Draft notes: + +- Setup and assumptions +- Observed behaviors and metrics +- Failure analysis and iteration plan diff --git a/_drafts/interface-mind-recursive-systems.md b/_drafts/interface-mind-recursive-systems.md new file mode 100644 index 0000000..8dda435 --- /dev/null +++ b/_drafts/interface-mind-recursive-systems.md @@ -0,0 +1,16 @@ +--- +title: "The Interface Between Mind and Recursive Systems" +author: Recursion Lab +tags: [cognition, systems, interaction] +--- + +How interacting with recursive AI/systems changes the way people think. + +- Cognitive reshaping, adaptation, feedback +- Case references to discuss (e.g., observation effects) + +Draft notes: + +- Interaction patterns (what users see, how they adapt) +- Risks (overtrust, loop amplification) +- Design implications (affordances, transparency) diff --git a/_drafts/recursive-reasoning-in-llms.md b/_drafts/recursive-reasoning-in-llms.md new file mode 100644 index 0000000..8abd131 --- /dev/null +++ b/_drafts/recursive-reasoning-in-llms.md @@ -0,0 +1,16 @@ +--- +title: "Recursive Reasoning in Language Models" +author: Recursion Lab +tags: [llm, recursion, prompting] +--- + +How LLMs currently do recursion (prompts, self-critique, looped tasks) + +- Pitfalls & limits (hallucinations, coherence collapse) +- Best practices / experiments + +Draft notes: + +- Prompt patterns (plan → draft → critique → revise) +- Tooling patterns (scratchpads, checklists, verifiers) +- Metrics and failure cases diff --git a/_drafts/what-is-symbolic-recursion.md b/_drafts/what-is-symbolic-recursion.md new file mode 100644 index 0000000..939c465 --- /dev/null +++ b/_drafts/what-is-symbolic-recursion.md @@ -0,0 +1,17 @@ +--- +title: "What Is Symbolic Recursion and Why It Matters" +author: Recursion Lab +tags: [recursion, cognition, ai] +--- + +Define symbolic vs. syntactic recursion. + +- Examples from cognition, prompt engineering, and AI +- Implications: self-reflection, emergent behavior, memory + +Draft notes: + +- Working definition(s) +- Short examples (language, programs, representations) +- Where it breaks or misleads +- Open questions diff --git a/_pages/projects.md b/_pages/projects.md new file mode 100644 index 0000000..9ee8695 --- /dev/null +++ b/_pages/projects.md @@ -0,0 +1,29 @@ +--- +title: Projects +layout: page +permalink: /projects/ +--- + +## Projects + +This page lists prototype ideas exploring recursive systems. Replace or expand these with your own projects as they evolve. + +### Recursive Self-Reflection Engine +- Goal: Prototype a system that self-evaluates outputs, detects contradictions, and regenerates improved responses. +- Sketch: Combine a language model with lightweight symbolic rules to create a feedback loop for critique → revise → verify. +- Notes: Inspired by work on emergent recursive cognition via language-encoded symbolic systems. Add links and code when available. + +### Recursive Reasoning Tools for LLMs +- Goal: Build tools or prompt frameworks that enforce recursive reasoning (multiple passes with critique and revision). +- Sketch: Design a reusable protocol (plan → draft → critique → revise) and measure quality gains on target tasks. +- Notes: Start with prompt-only approaches; evolve into lightweight libraries if useful. + +### Visualization of Feedback Systems +- Goal: Create visual/interactive models of recursive systems from biology, cognition, or social domains. +- Sketch: Show how loops amplify, stabilize, and collapse; let users tweak parameters to see phase changes. +- Notes: Consider small web demos or notebooks. + +### Cognitive Architecture Comparisons +- Goal: Compare architectures (e.g., CLARION and others) to locate where explicit vs. implicit recursion plays a role. +- Sketch: Build small simulations to highlight differences in learning and control loops. +- Notes: Collect references (papers, Wikipedia) and plan a minimal, comparable benchmark. diff --git a/_posts/2025-09-14-welcome.md b/_posts/2025-09-14-welcome.md new file mode 100644 index 0000000..2320d55 --- /dev/null +++ b/_posts/2025-09-14-welcome.md @@ -0,0 +1,10 @@ +--- +title: "Welcome — Recursion Lab" +date: 2025-09-14 09:00:00 +0000 +author: Recursion Lab +tags: [welcome, meta] +--- + +This is the first post on Recursion Lab. Replace this content with your own writing, sketches, or notes. Posts live in the `_posts/` folder — their filename controls their published date and URL. + +Write in Markdown, set front matter variables (title, date, tags), and push to `main` or open a PR. diff --git a/about.md b/about.md index b3231af..c600848 100644 --- a/about.md +++ b/about.md @@ -1,6 +1,23 @@ --- title: About layout: page +permalink: /about/ +--- + +## About + +Recursion Lab studies the interplay of recursion, cognition, and systems. We publish public notes and working prototypes that test ideas about feedback, self‑reference, and emergent behavior. + +We believe recursion is a core mechanism — in learning, in feedback, and in self‑reference. Through notes, experiments, and open-source prototypes we explore: + +- How recursive architectures enable emergent cognition +- How biological, computational, and social systems stabilize via feedback loops +- What happens when recursion is applied to meaning, memory, and identity + +This site is a research‑and‑prototype space. Browse the Blog for ongoing notes, and Projects for experiments you can try. Replace this paragraph with your contact or newsletter link when ready. +--- +title: About +layout: page --- ## About