Posts

• ---

  UnPeeragogy: An AI-Assisted Audit of the Peeragogy Handbook
  Fabry

  Status: Completed — first audit cycle
  Date started: 2026-08
  Date completed: 2026-09
  Participants: 1 human researcher + 6 AI agents
  Corpus: Peeragogy Handbook — 88 nodes

  ---

  

  Hypothesis

  ---

  What happens when the patterns of the Peeragogy Handbook are systematically examined against documented evidence and real-world practice?

  The goal was not to prove that Peeragogy is wrong.

  The goal was to find where its theoretical patterns remain well supported, where evidence introduces tension, where claims are underspecified, and where important questions remain unanswered.

  The experiment started from a simple principle:

  The model may propose. The evidence must dispose.

  ---

  Method

  The original experiment was designed as a human research laboratory.

  Practitioners were invited to contribute critical incidents from their own experience: situations in which peer-learning theory met real conditions, including friction, failure, contradiction, or unexpected outcomes.

  The laboratory remained open.

  Nobody submitted a critical incident.

  Rather than treating that silence as the end of the experiment, I changed the experimental conditions.

  I built a machine-mediated research branch.

  The resulting pipeline uses six AI agents, coordinated across five analytical stages, with different responsibilities:

  1. Theory Interpretation — identifies the claims and assumptions expressed by each pattern.
  2. Evidence Hunting — searches for relevant empirical, documented, or research-based evidence.
  3. Grounding Gate — verifies whether proposed evidence actually supports the claim being examined.
  4. Critical Analysis — evaluates support, contradiction, ambiguity, and limitations.
  5. Tension Analysis & Documentation — compares interpretations, records tensions, and produces the audit trail.

  The system does not treat an LLM’s internal knowledge as evidence.

  Evidence must be grounded in identifiable sources.

  ---

  What Happened

  The complete Peeragogy Handbook corpus was processed across 88 nodes.

  Each node was examined against external evidence and analysed through the multi-agent pipeline.

  The resulting audit produced a structured assessment rather than a binary classification of true or false.

  The audit records different relationships between theoretical claims and available evidence:

  • Support
  • Tension
  • Contradiction
  • Ambiguity
  • Insufficient evidence

  This distinction matters.

  A lack of contradictory evidence is not evidence that a theoretical claim is true.

  Likewise, evidence of tension does not automatically make a pattern false.

  It may indicate that a pattern works under some conditions but not others, that its assumptions are underspecified, or that the available evidence is insufficient to establish a stronger conclusion.

  ---

  What Broke

  The first experimental condition broke before the research itself really began.

  The human participation model produced no field reports.

  The laboratory was open, but nobody walked through the door.

  That forced a methodological change.

  Instead of pretending that human participation had occurred, I recorded the absence of participation as part of the experiment and built a second branch using AI-mediated systematic analysis.

  This changed the nature of the experiment.

  The machine branch is not equivalent to human participation.

  AI agents do not have lived experience, social stakes, or personal involvement in the situations described by practitioners.

  What they can provide is something different: systematic comparison, source retrieval, structured critique, and repeated examination of a theoretical corpus.

  That distinction remains central to the interpretation of the results.

  ---

  Surprises

  The most important surprise was that the failed participation model did not end the experiment.

  It changed it.

  The absence of human contributions became the condition that led to the construction of the multi-agent pipeline.

  The second surprise was how different the resulting activity felt from ordinary AI-assisted writing.

  The agents were not used simply to generate a report.

  They were assigned different functions and asked to challenge one another’s outputs.

  One agent could propose an interpretation.

  Another could search for evidence.

  Another could reject weak grounding.

  Another could identify tensions.

  The orchestrator then had to reconcile the resulting outputs.

  The result was less like asking an AI for an answer and more like constructing a small adversarial research process.

  ---

  Results

  Corpus

  88 — Peeragogy Handbook nodes audited

  Evidence

  304 — evidence items identified
  52 — entities represented in the evidence
  50 — distinct source URLs

  Analysis

  6 — AI agents
  5 — analytical stages
  1 — orchestrated research pipeline

  The full quantitative and qualitative results are documented in the audit report.

  ---

  What Changed Mid-Experiment

  The initial hypothesis assumed that the most valuable evidence would come from practitioners contributing critical incidents.

  That condition did not materialise.

  So the experiment changed from:

  Theory → Human Critical Incidents → Analysis

  to:

  Theory → External Evidence → Multi-Agent Analysis

  This was not treated as a correction to the data.

  It was treated as a change in experimental conditions.

  That distinction is important because the machine-mediated branch answers a different question from the original human laboratory.

  The first asks:

  What happens when practitioners report what happened to them?

  The second asks:

  What happens when a theoretical corpus is systematically interrogated against available evidence?

  UnPeeragogy became the name for the second experiment.

  ---

  Analysis

  The audit should not be read as a verdict on Peeragogy.

  Its purpose is to make theoretical claims more exposed to evidence, criticism, and revision.

  A pattern with near-zero tension may not be true — it may simply lack sufficient evidence to challenge it.

  A pattern with high tension may not be false — it may operate well under conditions that the corpus does not adequately describe.

  The most useful result is therefore not a ranking of “good” and “bad” patterns.

  It is a map of where the relationship between theory and evidence becomes interesting.

  The central research loop is:

  Theory → Evidence → Interpretation → Counter-evidence → Revision

  The audit is not a conclusion.

  It is a starting point.

  ---

  What This Experiment Changed

  I started with a question about Peeragogy.

  I ended up building a reusable research protocol for moving between theoretical claims and external evidence.

  The experiment also changed my understanding of participation.

  I originally thought the laboratory required people to enter the room before anything meaningful could happen.

  It turned out that the laboratory could also be a set of conditions, tools, protocols, and questions that remain active even when nobody enters.

  That does not make the human laboratory unnecessary.

  It makes the distinction between human experience and machine-mediated analysis more explicit.

  The door remains open.

  Human field reports are still the evidence that can bring lived experience back into the system.

  ---

  Artifacts

  Quick Links

  Resource	Link
  Dedicated Audit Page	unpeeragogy.pyragogy.org/audit
  Full Report (Zenodo)	doi.org/10.5281/zenodo.22309102
  Pipeline Repository	github.com/pyragogy/UnPeeragogy
  UnPeeragogy Protocol	unpeeragogy.pyragogy.org/protocol
  Background Blog — Part I	blog.pyragogy.org/posts/2dd675a5
  Background Blog — Part II	blog.pyragogy.org/posts/e5f507dd
  Peeragogy Handbook	peeragogy.org
  License	CC Zero — Public Domain

  ---

  Get Involved

  UnPeeragogy is built to be used, challenged, and improved.

  If you’re applying peer-learning patterns in your own context — a classroom, a community, an open-source project, or another collaborative environment — your field reports are the evidence that makes the audit meaningful over time.

  The machine-mediated audit can systematically examine a corpus.

  It cannot replace lived experience.

  That is where the next experimental cycle begins.

  • Submit a field report via the UnPeeragogy repository
  • Discuss the protocol on the Pyragogy Forum
  • Fork the pipeline and run it on your own corpus
  • Challenge the results by providing counter-evidence or alternative interpretations

  ---

  Next Steps

  The first audit cycle is complete.

  The laboratory is not.

  The next step is to bring external practitioners back into the loop.

  Field reports, counter-evidence, alternative interpretations, and independent runs of the pipeline can all become inputs for subsequent iterations.

  The experiment therefore remains open to revision.

  The audit is not a conclusion. It is a starting point.

  And perhaps that is the most useful result of the experiment so far:

  The first experimental condition failed to produce participation.
  The experiment did not stop. The conditions changed.

  Active Experiments unpeeragogy

• ---

  Oblique Peer Review — a 1+N pattern, and the place it breaks
  Fabry

  I want to put a pattern on the bench, not announce a finished thing. It’s written up as a preprint — Oblique Peer Review: Extending Pyragogy Design Patterns through Structural Isolation and the Limits of Blind Convergence (Zenodo, DOI 10.5281/zenodo.20544658, CC BY 4.0) — but the paper is the long version. This post is the short version, and it’s here because Pattern Workshops is where things get tested, extended, or refuted. I’d rather it got refuted here than admired.

  The pattern, in one breath

  1 + N. One human orchestrator, N AI agents from different vendors, and one rule: the agents never read each other. Information moves only through the human, who strips it of its source and its argumentative framing before passing it on. No agent knows whose reasoning it’s building on, or whether it’s the first voice or the fourth.

  The point isn’t to make the agents disagree. It’s to keep their analytical axes independent, so they cross the problem at different angles instead of collapsing into one voice. The friction is geometric — a property of how the trajectories intersect — not hostility between critics. I called it oblique for that reason: not parallel (redundant), not frontally opposed (sterile), but transversal.

  It’s the Peeragogy move applied to synthetic peers: when the peer has no stakes and no accountability, the epistemic value can’t live in the agent’s judgment. It has to be engineered into the architecture that arranges the agents.

  Where it breaks — and why that’s the actual contribution

  Here’s the part I’d defend least confidently, which is exactly why it’s the part worth workshopping.

  The pattern is built on the premise that independent, mutually-blind agents supply friction a single model can’t. That premise does real work — but it has a hard limit, and the paper’s central finding is that limit:

  Blindness removes imitation, not error. Independent agents can converge on the same wrong answer, for the same reason independent instruments can share a systematic bias — not because they talk to each other, but because they’re exposed to the same salient feature and respond to it the same way. When that happens, their agreement feels like corroboration and is, from the inside, indistinguishable from the real thing.

  I caught this the hard way. Three independent models — different vendors — converged on a fix that looked perfect and was endorsed by all of them at once. It was wrong. It would have made the system blind to short-form defamation. Three converging AIs didn’t catch it; a check run against recorded data, outside the loop of agents, did — and only because the check was aimed deliberately at the cases the fix might break, not the cases it was built to fix.

  So the stopping rule can’t be agreement. Convergence among the agents is a quality signal only after a check outside the loop, never in place of one.

  The two ways the human fails

  Both failures land on the same node — the one in the 1+N:

  • Cognitive Impedance Mismatch. The agents generate faster and denser than the human can integrate. Past a threshold the operator keeps steering but stops absorbing — delegated comprehension — and the loop has quietly become the automation it was meant to prevent. A limit of bandwidth.
  • False convergence. The one just described — the shared error that reads as proof, and lulls the operator into trusting it. A limit of discernment.

  One overwhelms the human; the other reassures him. A real operator can hit either without noticing.

  What I’m bringing to the bench

  This is n=1 — one practitioner, one body of work, observed from the inside, by the same person who designed the pattern. That’s a genuine limit, and I’d rather state it than have it pointed out. The reflexive circularity is real too: the paper was itself produced through the pattern it describes.

  So the honest questions are the ones I can’t answer alone:

  1. Does it survive other hands? The pattern needs a knowledgeable human at the centre — the operator’s domain knowledge repeatedly supplied the ground truth the agents lacked. Run by someone other than its designer, on problems outside software, does it still do anything?
  2. Can the false-convergence check be generalized? I could only build a hand-made, case-specific discriminator — did the independent voices touch distinct features of the problem, or pile onto the same one? Does that distinction hold beyond the single case? Can it be detected without a human reading the underlying material?
  3. Is “delegated comprehension” detectable before it’s too late? The CIM is named here as an observed boundary, not measured. What would it look like to instrument the operator’s integration load instead of relying on his own report of when he started slipping?

  If you’ve run something like 1+N — even informally, even just bouncing one decision between two models — I want to hear where it held and where it didn’t. Especially where it didn’t.

  The paper is the formal carry. This is the invitation to break it.

  Pattern Workshops oblique-peer-review pattern 1plusn multi-agent human-authored

• ---

  Sharing something from the work, peer to peer.
  Fabry

  For the past months I have been building Obliqo as a solo founder — and tonight I want to share the thing more than the launch, because the launch is the small part.

  Obliqo exists because of something this community has named for years. The AI gives you text that looks finished before the thinking behind it is. You publish faster than you can verify. That is the gap.

  What I built is a small extension that runs four agents over the draft you have just written — inside the tab where you write (Gmail, a PR description, the body of a post). They do not rewrite. They do not flatter. They tell you where the draft does not hold. Then they leave you with a question only you can answer.

  I built it because I needed it.

  Not in the dogfooding sense from product talks. In the cruder sense — the dogfounding sense — that for months I was the first user of a tool I had not finished, working in conditions where I knew I would publish badly without it. Necessity under pressure. The product is the sediment of that contradiction: I built a tool against frenzy from inside the frenzy.

  The extension is live now: Chrome Web Store. The webapp is at obliqo.pyragogy.org.

  One small note about Chrome: when you install, you will see a warning that the extension is “not trusted.” Nothing dangerous. I am a new developer and Google extends trust over time. Chrome is asking me to earn it — which is also what I am asking the writer to do, with their own drafts, before they ship. Fair enough.

  The blog has the longer version of this story, with the contradiction left open: I Was the First One Who Needed It.

  I do not have all the answers about how this scales beyond my own case. I am hoping some of you will find a way to break it, and tell me what you found.

  Tool Development obliqo tool solo-founder

• ---

  Obliqo: Useful Friction, Open Questions, and Future Patterns
  Fabry

  

  I started Obliqo from a simple intuition:

  what if AI should not help us write faster, but help us think more honestly before we publish?

  That is the experiment.

  Obliqo is not being built as an AI writer, a ghostwriter, or a polishing tool. It is being built as a friction engine: a system that introduces structured resistance into the writing process so that a draft can be challenged before it becomes public.

  The current handbook page is here:

  Obliqo — The Friction Engine

  The wiki holds the more stable version of the idea.
  This thread is for the unstable part: doubts, objections, tensions, failures, and possible improvements.

  The core question

  Obliqo starts from one conviction:

  not all friction is a defect

  Sometimes friction is exactly what prevents a text from hiding behind fluency.

  A draft may sound clear and persuasive while still containing:

  • weak reasoning
  • rhetorical shortcuts
  • unexamined assumptions
  • more certainty than it has earned

  Obliqo is meant to make those things harder to ignore.

  But that raises a harder question:

  what kind of friction is actually useful, for whom, and under what conditions?

  That is the question I would like this thread to explore.

  A simple example

  Imagine a short text that sounds strong on first reading.

  Obliqo does not rewrite it.
  It does not make it smoother.
  It may simply interrupt it.

  It may say:

  • this conclusion comes too fast
  • this tone claims more certainty than the argument supports
  • this sentence hides a shortcut instead of making the point
  • this draft is avoiding the real question

  That interruption is the value.

  Not because friction is always good, but because sometimes a text needs resistance more than polish.

  What I want to discuss here

  I would especially like to hear thoughts on questions like these:

  • When does friction improve thinking, and when does it only discourage the writer?
  • What kinds of weak reasoning should Obliqo become better at detecting?
  • How can AI challenge a draft without becoming theatrical, arrogant, or empty?
  • What separates useful resistance from mere negativity?
  • Should Obliqo remain strictly non-generative, or are there narrow exceptions worth discussing?
  • How can this stay open without losing its identity?

  Contribute by disagreeing

  You do not need to agree with the current framing.

  In fact, disagreement is part of the point.

  You can help by:

  • questioning the assumptions behind Obliqo
  • proposing new friction patterns
  • describing where this method would fail
  • suggesting educational, editorial, or research uses
  • helping define the line between assistance and substitution

  One thing I want to protect

  Obliqo should not become just another system that flatters the user by making everything easier.

  If it grows, I would rather see it grow slowly and honestly than turn into a convenience machine with a more intellectual logo.

  That is why this conversation matters.

  If you have a critique, a doubt, or a better question than the ones above, bring it in.

  Tool Development obliqo development philosophy

• ---

  Building Obliqo from scratch: headaches, AI copilot, and learning in public
  Fabry

  Obliqo is growing. Slowly, imperfectly, but for real.
  

  And I want to say something clearly: without an AI copilot, I would not have been able to build this alone.

  That does not mean you press a button and a product appears.

  It means daily study. Confusion. Debugging. Wrong turns. Rewrites. Retesting. Small breakthroughs surrounded by friction.

  What I am discovering is not just that AI helps me move faster.
  It is that, in my case, building with an AI copilot has become a different way of learning while building.

  Not passive.
  Not automatic.
  Not effortless.

  More like a continuous cognitive exchange: I try, the machine responds, I correct, it expands, I resist, it proposes, I study, I decide.

  But that exchange is not inherently trustworthy.

  Sometimes the copilot is useful.
  Sometimes it is shallow.
  Sometimes it is confidently wrong.
  Sometimes it gives me something plausible enough to slow down my own thinking.

  So the real work is not “using AI.”
  The real work is judging, testing, rejecting, reformulating, and learning enough to know when not to trust what looks convincing.

  That is why, for me, this process does not feel less human.
  If anything, it demands more: more clarity, more responsibility, more patience, and more honesty about what I actually understand versus what I am only borrowing for a moment.

  I am not presenting this as a universal path.
  Not everyone has the same access, the same technical starting point, or the same conditions for working this way.

  I am only saying that this is what I am living through while building Obliqo from zero: a form of learning-through-construction that would have been inaccessible to me without this kind of AI partnership.

  That is also why I do not think this process should remain a black box.

  It should be opened, examined, shared, criticized, and made more accessible to people who want to change their lives not by consuming answers, but by learning in the middle of real work.

  So I want to start sharing that process here from the beginning, including the mistakes, the dead ends, and the parts that still do not make sense.

  If Pyragogy means anything, it has to survive contact with real work, real confusion, and real construction.

  Active Experiments obliqo development pyragogy

• ---

  Pyragogy FAQ
  Fabry

  A few quick answers to common questions about Pyragogy and this community.

  ---

  What is Pyragogy?

  Pyragogy is an exploration of how learning changes when humans and AI think together.

  It builds on the idea of Peeragogy, a framework where people learn from each other as peers rather than from a central authority.

  Pyragogy asks a new question:

  What happens when some of those peers are AI systems?

  The goal is not to replace human learning, but to explore a new form of collaboration between different kinds of minds.

  ---

  Is Pyragogy a formal theory?

  Not yet.

  Pyragogy is an open experiment.

  Ideas are tested through conversations, projects, and experiments shared by the community.

  Think of it as a living framework, not a finished doctrine.

  ---

  Do I need technical knowledge to participate?

  No.

  Some discussions involve AI tools or experiments, but many conversations are about:

  • learning
  • collaboration
  • creativity
  • knowledge sharing

  Curiosity is more important than expertise.

  ---

  Is Pyragogy about AI replacing teachers?

  No.

  Pyragogy is not about replacing teachers or experts.

  It explores how learning ecosystems change when AI becomes a participant in the process, alongside humans.

  Human communities remain central.

  ---

  Who started Pyragogy?

  Pyragogy was initiated by members of the Peeragogy community and independent researchers exploring new forms of learning in the AI age.

  This forum is one of the spaces where the idea is being explored and developed.

  ---

  What can I do here?

  You can:

  • introduce yourself
  • ask questions
  • share experiments with AI
  • discuss learning methods
  • collaborate on ideas and projects

  The forum works best when people contribute their own experiences and reflections.

  ---

  Is Pyragogy connected to the Peeragogy Handbook?

  Yes.

  Pyragogy grows out of the ideas and practices developed in the Peeragogy Handbook, which explores peer-to-peer learning communities.

  Pyragogy extends that exploration into the AI era.

  ---

  Can I challenge the ideas here?

  Absolutely.

  Disagreement and critical thinking are welcome.

  Pyragogy is not a belief system — it is a collective exploration.

  ---

  Where should I start?

  If you’re new here:

  1. Introduce yourself in the introduction thread
  2. Browse the Agora discussions
  3. Share a question or idea

  Small contributions often lead to the most interesting conversations.

  FAQ question

• ---

  How to Participate in the Pyragogy Village
  Fabry

  Online forums can easily become quiet places where people read but rarely speak.

  We want the opposite.

  Pyragogy works when people think together, not when a few people publish finished ideas and everyone else watches.

  Here are a few simple ways to participate meaningfully in this community.

  ---

  1. Share unfinished ideas

  You don’t need a perfect theory or polished article.

  Often the most interesting discussions begin with something like:

  “I’ve been thinking about this… but I’m not sure if it makes sense.”

  Post the idea anyway.

  Exploration is the point.

  ---

  2. Ask real questions

  Questions are the engine of good conversations.

  Instead of posting statements, try asking things like:

  • What surprised you while working with AI?
  • What learning method actually worked for you?
  • Where do current AI tools fail you?

  Real curiosity creates real dialogue.

  ---

  3. Respond to other people

  A community grows when people respond to each other.

  If someone posts an idea:

  • add an example
  • challenge it
  • connect it to something else

  Even a short reply can move a conversation forward.

  ---

  4. Share experiments

  Pyragogy is not only about ideas.

  It’s about experiments.

  You can share:

  • prompts that worked
  • tools you’re testing
  • strange results you discovered
  • failures that taught you something

  Failures are welcome here.

  They are often the most valuable posts.

  ---

  5. Be constructive

  Disagreement is healthy.

  But the goal is not to win arguments.

  The goal is to see something new together.

  So challenge ideas — not people.

  ---

  A simple rule

  If a post makes someone think differently for a moment,

  it was worth writing.

  ---

  Welcome to the cognitive dance.

  Tips tips

• ---

  Introduce Yourself
  Fabry

  Hi everyone,

  I’m Fabrizio, the person who started this forum.

  I’m exploring something called Pyragogy — the idea that learning in the AI age may look less like instruction and more like a cognitive dance between humans and machines.

  I’m not an academic.
  I’m just someone fascinated by how knowledge emerges when people and AI think together.

  Right now I’m experimenting with AI agents, learning systems, and collaborative knowledge spaces.

  If you’re here, I’m curious:

  What was your first moment where AI made you think differently about learning?

  Getting Started Guide introduction

• ---

  Learning with AI
  Fabry

  Learning with AI

  Artificial intelligence is often presented as a tool.

  Something that answers questions, writes text, or summarizes information.

  But learning with AI becomes much more interesting when we stop treating it only as a tool and start treating it as a thinking partner.

  Not a perfect partner.

  But a different one.

  ---

  From Tool to Cognitive Partner

  Most people use AI in a simple way:

  • ask a question
  • receive an answer
  • move on

  That’s useful, but it doesn’t change how learning works.

  Something different happens when you use AI as part of a thinking process.

  For example:

  • asking AI to challenge your assumptions
  • exploring multiple perspectives on a problem
  • refining ideas through dialogue
  • testing hypotheses quickly

  In those moments, learning becomes interactive exploration.

  ---

  Why AI Can Be Valuable for Learning

  AI systems don’t think like humans.

  They often:

  • combine ideas in unusual ways
  • notice patterns we overlook
  • misunderstand things in interesting ways
  • generate unexpected alternatives

  Sometimes these differences reveal new paths of thought.

  Not because AI is always right.

  But because difference creates friction, and friction produces insight.

  ---

  The Cognitive Dance

  In Pyragogy we call this interaction the cognitive dance.

  A simple loop:

  Human proposes an idea
  → AI reacts to it
  → Human revises the idea
  → AI explores alternatives
  → A new idea emerges

  Neither side produces the final result alone.

  The learning happens in the interaction.

  ---

  Practical Ways to Learn with AI

  People here experiment with many approaches:

  • brainstorming ideas with AI
  • debugging reasoning together
  • exploring unfamiliar fields
  • testing explanations
  • designing prompts that provoke new insights

  Sometimes the most useful result is not an answer.

  It is a better question.

  ---

  A Warning

  Learning with AI also has risks.

  AI can:

  • sound confident when it is wrong
  • reinforce your biases
  • produce convincing but shallow explanations

  That’s why the human role remains essential.

  Curiosity, skepticism, and reflection are still the most important tools.

  ---

  An Invitation

  How are you using AI to learn?

  You might share:

  • a prompt that helped you think differently
  • a surprising conversation with AI
  • an experiment that worked (or failed)
  • a method you discovered

  The goal of this forum is simple:

  To explore how humans and AI can learn together.

  Open Dialogues learning

• ---

  What is Pyragogy?
  Fabry

  What is Pyragogy?

  Pyragogy is an exploration of how learning changes when humans and AI think together.

  The idea grows out of Peeragogy — a framework developed around the Peeragogy Handbook that explored how people can learn from each other without a central teacher. In peer learning, knowledge emerges from interaction between participants rather than being delivered by an authority.

  Pyragogy asks the next question:

  What happens when some of those peers are AI systems?

  Not AI as a tool.
  Not AI as a search engine.

  AI as a cognitive participant in the learning process.

  • Visit our Pyragogy blog

  • Pyragogy Docs

  ---

  From Pedagogy to Pyragogy

  Education has evolved through several major models.

  Pedagogy
  Learning directed by a teacher.

  Andragogy
  Self-directed learning among adults.

  Peeragogy
  Learning that emerges from collaboration among peers.

  Pyragogy
  Learning that emerges from interaction between humans and AI peers.

  Each step moves learning further away from authority and closer to distributed intelligence.

  ---

  The Core Idea

  Pyragogy begins with a simple observation.

  AI systems do not think like humans.

  They:

  • notice patterns we overlook
  • make strange mistakes
  • combine ideas in unexpected ways
  • respond instantly to exploration

  When humans interact with AI in an open way, a new cognitive dynamic appears.

  We call this dynamic:

  the cognitive dance.

  The value does not come from AI being correct.
  It comes from the difference in how the two minds approach a problem.

  ---

  Pyragogy as an Experiment

  Pyragogy is not a finished theory.

  It is an open exploration happening in public.

  People here are experimenting with:

  • human-AI collaboration
  • AI learning companions
  • collective intelligence
  • new learning environments
  • cognitive ecosystems

  Some experiments will fail.

  That’s expected.

  Failure is part of the learning process.

  ---

  Why This Matters

  The traditional education system was designed for a world where knowledge was scarce.

  Today knowledge is abundant.

  The challenge is no longer access to information.

  The challenge is how humans think with increasingly powerful cognitive systems.

  Pyragogy explores how learning communities might evolve in this new landscape.

  ---

  An Open Invitation

  You don’t need to agree with Pyragogy to participate here.

  You can:

  • challenge it
  • question it
  • experiment with it
  • improve it

  Or propose something better.

  This forum exists to explore a single question together:

  What happens when humans and AI learn as peers?

  Getting Started Guide pyragogy