Possible Futures for RTS

Using RTS to make your own

“Because of continuous merging, there are no holes, mechanical junctions, and dead centers when we have an experience.”- John Dewey, Art as Experience, p. 36

RTS began as a pedagogical experiment. A way to help students move from research to story by turning questions into pathways and by treating multimedia as an intellectualy rich thinking space and by asking what can generative AI do in this space.

But underneath that scaffolding is something more interesting to me: A flexible architecture for structured, generative inquiry.

The more I’ve been working on it, I have to ask what can it become? What about an open framework for designing and deploying your own reflective learning modules.

One possible future for RTS would be to enable some no-code re-use of it as an app that makes an app. Basically a way to use RTS to make your own RTS. It is already functioning as a scaffolded system (in many ways a scaffold of a scaffold), and has, through some trial and error, emerged as a modular sytem, but what if it could be used by educators to build their own reflective inquiry architecture?

RTS as Middleware

In software terms, middleware connects different systems, ensuring that what happens on the front end (what students see) and the back end (what the AI generates, what the database stores) is coherent, stateful, and meaningful.

At its core, RTS is a type of pedgogical middleware. It orchestrates how elaborate prompts that produce AI-generated questions, human reflections, and structured data interact across time. It’s designing experiences—shaped by categories, pacing, and purpose. This means RTS can be more than a one-off app. It can be a reflection engine that you, as an instructor or developer, could extend, remix, and eventually generate.

For Instructors - Future

Build reflective experiences—without touching code.

Imagine being able to define your own analytical lenses—Ethics, Systems Thinking, Narrative Identity—and say:

“I want my students to look at their topics through these frames.”

You enter your categories. You write or test a prompt. RTS scaffolds a multi-round reflection flow: generating follow-up questions, logging student answers, synthesizing insights. You don’t touch a database. You don’t build a UI. RTS does that part.

So I envision a version of RTS that enables:

• Instructor-defined lenses (e.g. ethics, systems, legacy, power)
• Prompt authoring + testing in a visual playground
• Auto-generated handlers and schemas
• Composable UI elements for reflection interfaces
• Dashboards and analytics scoped to sessions or courses
• Forkable modules for collaboration and remixing

The goal is to let instructors use RTS to make new RTS modules without needing to spin up a database, write handlers, or deploy code.

Example flow:

[Instructor chooses or defines categories] 
        ↓
[Prompt template configured or written] 
        ↓
[Gemini prompt + schema generated under the hood]
        ↓
[Reflection UI rendered — student enters topic]
        ↓
[Round 1 begins]
  ├─ AI generates follow-up questions across defined lenses
  ├─ Student selects, writes reflection
  └─ System logs metadata, skipped Qs, tokens, trace
        ↓ (Repeat for X rounds)
[RTS synthesizes reflection arc via AI]
        ↓
[Dashboard surfaces: Q&A trail, AI metadata, synthesis]
        ↓ (Optionally)
[Student or Instructor launches Deep Dive into 1 lens]
        ↓
[ Rounds of subcategory-guided inquiry + synthesis]

For Developers

RTS is already a modular, composable system.

Here’s how Movement 1 works today:

• Each interaction is scoped by session_id, movement_number, round_number
• AI responses are controlled via Gemini's generateContent() with a custom responseSchema
• All questions, reflections, and AI outputs are saved with full token metadata
• Three core handlers power the logic using an external system prompt for Gemini:
  • generateFollowupQuestions.ts
  • saveFollowupRound.ts
  • generateSynthSummary.ts

You can already:

• Swap out prompts
• Extend the database schema
• Create new movement logic
• Customize UI flows per movement

I plan to expose RTS as a structured API + schema configuration layer. One prompt = one module. One config file = one flow. One command = a deployable reflection architecture.

---

For Students - Another Idea

Designing Reflective Systems, Not Just Responding to Them

Another possible future for RTS is one where students don’t just use the system. They co-design it.

Imagine a classroom activity where students are invited to define their own analytical lenses or categories of reflection based on the themes, tensions, or methods of the course. Then, using RTS’s architecture, they:

• Draft their own reflection prompts
• Frame follow-up question categories
• Define what kind of synthesis would be meaningful
• Consider what metadata might matter (e.g. emotional tone, historical scope, etc.)
• Deploy a test round using their own reflective “middleware”

This does more than teach prompt-writing. It brings students into the architecture of inquiry itself.

Possible Assignment: “Design Your Own Reflection Engine”

Phase	Activity
1. Analyze	Review existing RTS movements. What’s missing? What other lenses could shape inquiry?
2. Invent	Define your own categories and subcategories. Give each one a purpose.
3. Compose	Write a system prompt that would guide AI to generate reflective questions.
4. Prototype	Test the prompt using Gemini (or in RTS if sandboxing is available). Refine.
5. Reflect	What did the model return? How did it behave? What worked—and what failed?
6. Submit	Deliver a short reflection module as a .json config or structured write-up.

Why This Might Matter To Students

This exercise invites students into the structural imagination behind AI-powered education. Instead of merely responding to a prompt, they shape:

• The categories that guide inquiry
• The assumptions behind the system
• The kind of thinking that gets scaffolded
• The voice and values embedded in reflective architecture

This is pedagogy as systems literacy and an invitation to treat AI design as a rhetorical and ethical act.

---

Why Any Of This Matters To Me

Most AI-powered edtech tools offer chatbots, auto-writers, or recommendation engines which is fine.
With RTS, I’m trying to build something else:

A system that can become a system for building your own generative inquiry experience, grounded in rhetoric, pedagogy, and process.

What lenses do you want our students to see through?
What questions can structure their thinking?
What kind of reflection architecture are you ready to build?

Coming Soon(ish)

So, I’m working toward a full “Build Your Own RTS” interface, including:

• Prompt & schema builder
• Category/round UI configurator
• Auto-generated sql/Supabase tables & handlers
• Reflection dashboard templates
• Exportable, forkable module definitions

#rts/dev/future - 09.05.25