Outcry in Code: Developing an Activist AI for Social Movements

Introduction

This report documents our experience developing a proprietary AI model specifically designed to support activism and social organizing. The work stems from OutcryAI's mission to create a superintelligent AI that amplifies the capacity of organizers rather than extract value from movements. Our approach, at this initial stage, was methodical in preparation for revolutionary steps in the future: we took an existing instruction-tuned model and systematically adapted it for activist use through domain-specific pre-training (DAPT) followed by conversational fine-tuning (LoRA).

The technical choices we made were constrained by practical computational and financial limitations faced by activists. This isn't a paper touting a breakthrough but rather a field report on what we learned about applying large language model training to the needs of activists, organizers and protesters.

Context and Motivation

Most AI development serves commercial interests, with models optimized for engagement or revenue. The activist community has different priorities: we need tools that help organizers think strategically, escape the old protest scripts, provide accessible education about movement history, and support tactical decision-making without compromising radical imagination.

Our goal at this stage was modest: train a conversational AI that could serve as a knowledgeable resource for activists. We wanted something that understood the strategic context of different radical currents, could draw on historical precedents, and could engage with the complex ethical questions that arise in movement work.

The Evolution of Activist AI

OutcryAI, as deployed today at www.outcryai.com, is the precursor to our first fine tuned model. To provide context for our experiments, let's explain the current system.

ProtestGPT v1

ProtestGPT v1 represented our first systematic attempt to create AI-powered tools for activist campaign generation. Built as a Python-based automation system, it leveraged OpenAI's GPT-4 API to generate structured protest campaign concepts through a novel pseudo-language interface we developed called "ProCampGen."

The system's architecture was deliberately pragmatic, designed to run continuously and generate campaign ideas at scale. The core workflow involved three main components: parameter selection, content generation, and automated publishing. Campaign parameters were randomly selected from curated JSON files containing arrays of campaign types, topics, target audiences, desired impacts, resource limitations, and ideological frameworks. These parameters were then encoded into a compact pseudo-language format—for example, "CT[Climate Change] Tp[Performance] TA[Politicians] DI[Legislation Changes] RL[I want to spend less than $100] TC[90] I[Liberalism (Centrist)]"—that served as input to the GPT-4 model.

The heart of ProtestGPT v1 was its comprehensive system prompt, which established a detailed specification for campaign generation. Rather than simple question-and-answer interactions, the system prompted GPT-4 to produce extensive, structured essays written from the perspective of activists with specific political ideologies. Each generated campaign included eight distinct sections: a campaign idea, detailed description, theoretical framework for change, press release, flash fiction origin story, opponent analysis, response strategies, and implementation steps. This format ensured that each campaign concept was thoroughly developed and actionable.

The system's output was formatted as Hugo-compatible markdown files, complete with frontmatter metadata including SEO titles, descriptions, publication dates, and tags. Generated content was automatically saved to a Hugo static site generator, which would then build and deploy the content to GitHub Pages. This automation pipeline meant that ProtestGPT v1 could operate continuously, generating up to 50 campaign concepts per run with built-in rate limiting to respect API constraints.

A notable feature was the system's integration with visual generation capabilities through DALL-E prompts. The codebase included infrastructure for extracting campaign concepts from generated text and creating corresponding image prompts, though this remained largely preparatory work for future visual integration.

From a technical perspective, ProtestGPT v1 demonstrated several important design decisions. The use of structured JSON parameter files made it easy to modify campaign generation parameters without code changes. The pseudo-language interface provided a compact way to encode complex campaign requirements while maintaining readability. The automated publishing pipeline showed how AI content generation could be integrated into existing web infrastructure.

However, the system's design also revealed important limitations. The reliance on random parameter selection meant that campaign concepts, while creative, weren't responsive to current events or specific organizing needs. The batch generation approach optimized for quantity over targeted relevance. Most significantly, the system was purely generative—it created campaign ideas but provided no mechanism for feedback, refinement, or interactive development of concepts.

ProtestGPT v1 succeeded in demonstrating that AI could generate sophisticated, theoretically grounded campaign concepts at scale. The pseudo-language interface proved effective for structuring complex campaign parameters, and the automated publishing pipeline showed how AI-generated content could be integrated into activist web infrastructure. These lessons directly informed our subsequent development of more interactive and responsive AI tools for activist organizing.

The brain behind ProtestGPT v1 was this pseudo-language prompt:

The following campaign concept demonstrates ProtestGPT v1's ability to generate comprehensive, theoretically grounded activism strategies complete with tactical considerations, messaging frameworks, and implementation roadmaps.

ProtestGPT v2

ProtestGPTv2 represented a significant architectural evolution from its predecessor, transitioning from simple campaign generation to a sophisticated multi-agent reasoning system designed to produce deeply considered responses to activist strategic questions. Built around OpenAI's Batch API, the system orchestrated multiple AI agents through sequential processing stages, each agent bringing specialized perspective and capabilities to complex organizing challenges.

The system's core architecture centered on a python script, which implemented a YAML-driven multi-agent workflow. Rather than generating random campaign concepts, ProtestGPTv2 processed specific strategic questions through a carefully designed pipeline. The system read questions from a simple text file—questions like "Why do protests fail?" and "How can I most impactfully protest Trump?"—and subjected each to analysis by multiple specialized AI agents operating in coordinated stages.

The multi-agent architecture was defined through a comprehensive YAML configuration that specified five distinct agent types, each with unique instructions, capabilities, and access to specialized knowledge bases. The Association Agent functioned as a psychoanalytic stream-of-consciousness thinker, exploring activism through creative, nonlinear connections across diverse fields and surfacing unexpected analogies that illuminated power structures. The Mentor Visionary operated as Micah White himself, offering broad, imaginative ideas that upended conventional assumptions about protest, while the Mentor Action agent translated these bold concepts into concrete, immediately usable tactics and campaign concepts.

The system's knowledge architecture leveraged multiple vector stores containing different types of activist knowledge. The Association Agent accessed a general knowledge base for creative connections, while both Mentor agents drew from specialized collections of Micah White's writings, notes, and theoretical frameworks. This RAG-based approach allowed each agent to ground their responses in relevant source material while maintaining their distinct analytical perspectives.

Processing occurred through a sophisticated staging system where agents operated in sequence, with later stages building upon earlier outputs. The Association Agent would first provide unconscious, creative reflections on a question. These reflections were then fed to the Mentor agents, who used them as [thoughts] to inform their more structured strategic analysis. The system supported variable stage configuration, including optional agents like a Historian that could be toggled on or off depending on processing requirements.

The technical implementation demonstrated significant advances in workflow automation and resource management. The system used OpenAI's Batch API to process multiple requests efficiently, implementing comprehensive logging, error handling, and result processing. Each processing run generated timestamped output directories containing both intermediate files from individual agents and final synthesized responses. The system even generated RSS feeds for easy consumption of the strategic analysis.

Most notably, the final processing stages involved an Editor Agent that transformed the raw strategic analysis into polished prose using a sophisticated writing framework. This agent was instructed to fuse Jenny Offill-style fracture with either Jia Tolentino's cultural commentary or Hanif Abdurraqib's musical sensibility, creating engaging, mobile-optimized content. A Reviewer Agent then transformed this content into TikTok-ready scripts, demonstrating the system's readiness for today's media consumption patterns.

The system's output quality reflected the sophisticated prompt engineering and agent specialization. Rather than generating generic campaign concepts, ProtestGPTv2 produced nuanced strategic analysis that combined historical context, theoretical frameworks, and practical tactics. The multi-agent approach allowed for both creative, associative thinking and rigorous strategic analysis within the same response.

However, the system architecture also revealed important limitations. The reliance on sequential processing meant that later agents were constrained by earlier outputs, potentially limiting the diversity of analytical approaches. The system remained batch-oriented rather than interactive, producing comprehensive reports rather than supporting conversational refinement of ideas.

ProtestGPTv2 succeeded in demonstrating that multi-agent systems could produce sophisticated strategic analysis for activist questions. The YAML-driven configuration made it possible to experiment with different agent combinations and processing pipelines without code changes. The integration of multiple knowledge bases through vector search showed how specialized domain knowledge could be made accessible to AI reasoning. These architectural insights directly informed our subsequent work on creating more interactive and conversational AI tools for organizing.

Sample Output from ProtestGPTv2

The brain behind ProtestGPT v2 was this multi-agent system:

ProtestGPT v2 was remarkable for generating highly creative activist writings:

OutcryAI.com v1

OutcryAI.com represents a sophisticated application of prompt engineering and system design principles to create a specialized conversational AI for activists. At its core, the system is a carefully orchestrated wrapper around OpenAI's GPT-4.1 model, transformed through an extensive 4,500+ word system prompt into a strategic advisor that channels the theoretical frameworks and provocative insights of activist theorist Micah White.

The application architecture reflects the practical needs of movement technologists: it's built with Next.js and TypeScript, deployed on Vercel, and designed to be both accessible and scalable. The system also prioritizes user privacy and implements privacy-preserving features like header hashing for user anonymity.

What distinguishes OutcryAI from generic AI assistants is its specialized knowledge base and conversational persona. The system prompt encompasses detailed taxonomies of protest tactics, historical case studies from movements worldwide, strategic frameworks for analyzing different approaches to social change, and carefully curated examples of how to apply these concepts to contemporary organizing challenges. The AI is programmed to respond with Micah White's distinctive voice—reflective, provocative, and rooted in radical practice—while maintaining strict topical focus on activism, protest strategy, and movement building.

In developing OutcryAI, we learned that a knowledge base within the AI's system prompt could effectively replace RAG and vector search.

The current system prompt processes user questions through multiple validation layers: it checks for attempts to override its core identity and consistently grounds strategic advice in historical precedents and theoretical frameworks. Every response ends with either a follow-up question or a "micro-provocation" designed to deepen the user's strategic thinking.

While functionally sophisticated, this system represents the foundation rather than the destination of our work. It demonstrates that specialized AI applications can created using prompt engineering atop OpenAI's models and serve movement needs effectively, but it also highlights the limitations of depending on commercial AI providers for tools that should serve social and political revolutionary purposes. To reach its full potential, it is clear that OutcryAI must be built atop a custom model that is fully fine tuned for our purposes. This will allow us greater control over the generations and also the ability to serve the model at scale.

Onward to OutcryAI Version 2

As it is now, OutcryAI works, the activists that are using it tend to return and the answers it is giving are quite good. It is particularly gratifying to see Outcry respond to questions that its human creator would struggle to answer adequately. However, the entire app is dependent on OpenAI and is, quite frankly, expensive to run as we must pay OpenAI for every word the model generates. This limits our ability to scale to thousands, if not tens of millions of users.

The decision to develop our own fine-tuned model emerged from both philosophical and practical considerations. While OutcryAI.com demonstrated the viability of specialized activist AI through prompt engineering, relying entirely on OpenAI's commercial infrastructure created fundamental tensions. Every response was subject to OpenAI's content policies and rate limits, and the underlying model remained a black box controlled by commercial interests rather than activist communities.

The path forward became clear: we needed to create a model that was fundamentally trained for activist purposes rather than retrofitted through prompting. This meant accepting the computational costs and technical complexity of fine-tuning our own model, but it also meant gaining the independence, control, and specialized capability that radical activism demands. By training directly on activist literature through domain adaptive pre-training (DAPT) and then fine-tuning on real organizing conversations (LoRA), we could create an Activist AI that was genuinely built for activists rather than adapted for them.

Technical Approach: Two-Phase Training

We used a two-phase approach that has become standard in domain-specific AI development. First, we conducted Domain Adaptive Pre-Training (DAPT) to expand the model's knowledge of activist literature and organizing concepts. Then we used Low-Rank Adaptation (LoRA) to teach the model to engage in helpful conversations about activism.

Phase 1: Domain Adaptive Pre-Training (DAPT)

Base Model Selection
We started with Mistral-7B-Instruct-v0.3, chosen for practical reasons: it's capable enough to handle complex reasoning about strategy and tactics and small enough to train on modest hardware. In other words, the 7B parameter size represents a reasonable balance between capability and computational efficiency. We were ultimately convinced to use this particular model after conversing with it, and other smaller models, about activism. Out of the box it had the best understanding of protest theory.

Training Data Preparation
Our activist corpus came from processing literature across multiple domains using a production-grade text extraction pipeline. The activist corpus included historical movement documents, strategy guides, case studies of organizing campaigns, contemporary analysis of social movements, along with thousands of pages of activist thought. This wasn't an attempt to capture all activist knowledge, but rather to provide a foundation in core concepts, historical precedents, and strategic frameworks with a leftist perspective with an emphasis on both anarchism and nonviolence. The final training set was 700,000,000 tokens, which is roughly 500 million words.

DAPT Training Process
We developed a custom script to manage the workflow of running one epoch of continued pre-training on the activist corpus. We used Runpod servers running the Runpod Pytorch 2.2.0 template. Our script handled installing additional prerequisites, running the DAPT training and shutting down the server when it completed.

The training configuration was conservative:

• Learning rate: 1e-4 with cosine scheduling
• Batch configuration: Per-device batch size of 1 with gradient accumulation of 32 steps
• Memory optimization: bfloat16 precision, gradient checkpointing, and careful attention to memory usage
• Checkpointing: Saved every 1000 steps with automatic cleanup to manage disk space

The process took approximately 48 hours on a single GPU, training on approximately 50GB of processed activist texts. We monitored for catastrophic forgetting by periodically checking that the model retained its general reasoning capabilities.

Phase 2: LoRA Fine-tuning for Conversation

Dataset Construction
The conversational training phase used real conversation data from the OutcryAI system—several hundred multi-turn authentic interactions between users and the Outcry assistant. This was supplemented by close to 2000 AI to AI conversations based on the activist corpus. For these conversations, an AI would ask Outcry a question based on an activist text that we used in the DAPT fine tune. The AI would also provide Outcry with a summary and excerpt. Outcry's response was then used to fine tune the new model.

Training Strategy
We used Low-Rank Adaptation to fine tune the DAPT fine tuned model. The LoRA training used completion-only learning, where the model only learned from assistant responses. This prevents the model from learning to mimic user behavior and ensures it focuses on generating appropriate responses. The training ran for 263 steps with these parameters:

• Learning rate: 5e-5 (higher than DAPT to enable faster adaptation)
• Batch size: 4 per device with gradient accumulation
• Sequence length: 512 tokens (shorter for conversational exchanges)
• Mixed precision: bfloat16 for efficiency

Results and Evaluation

DAPT Outcomes
The domain adaptive pre-training successfully expanded the model's knowledge of activist concepts. Qualitative evaluation showed improved understanding of:

• Historical context: Better knowledge of past movements and campaigns
• Strategic frameworks: Understanding of different organizing models and approaches
• Tactical considerations: Awareness of the trade-offs between different action types
• Movement culture: Familiarity with activist terminology and concepts

LoRA Training Results
The conversational fine-tuning achieved strong technical metrics:

• Final loss: 3.05 (indicating good convergence)
• Token accuracy: 42% (solid performance for this task)
• Response quality: Generated coherent, contextually appropriate responses

Practical Performance
The fine tuned model demonstrated several useful capabilities:

• Accessible explanations: Can explain complex organizing concepts in understandable terms
• Strategic thinking: Helps users think through campaign planning and tactical decisions
• Historical knowledge: Draws on movement history to inform contemporary questions
• Conversational flow: Maintains context across multi-turn exchanges

Lessons Learned

Overall, we view this first attempt at training a custom activist large language model as a success. We demonstrated the ability to DAPT and LoRA fine tune an activist AI model and learned that a 7b model is insufficient.

Still, the fine tuned model lacked the complex reasoning ability of OpenAI's 4.1 model which means that the answers provided by the prompt engineered Outcry were superior, in every conversation, to the fine tuned Outcry model. See below for a comparison of the two models.

Our next step will be to repeat the DAPT and LoRA fine tune on a larger model. In the meantime, we continue to add new features to the existing prompt engineered Outcry, such as the newly implemented memory that remembers conversations with logged in users to give better answers.

Conclusion

This project represents a small but concrete step toward AI that serves movements rather than extracting value from them. The technical approach—domain adaptive pre-training followed by conversational fine-tuning—proved moderately effective for creating a specialized assistant that understands activist contexts and can engage helpfully with organizing questions.

The methodology we developed is reproducible and adaptable. Other movement technologists can use similar approaches to create AI tools for their specific contexts and needs. The scripts, configurations, and lessons learned from this project provide a foundation for our future work in movement AI development.

The model we created isn't good enough to compete with prompt engineered OpenAI, but it's a helpful demonstration of the feasibility of building a custom trained Activist AI model.