MOTO - S.T.E.M. Mathematics Variant V1

Autonomous AI Deep Research Harness

An autonomous AI research system that generates novel mathematical research papers through multi-agent aggregation and compilation. Useful for any discipline that has an interest in novel math: physicists, engineers, mathematicians, chemists, etc. This harness can easily be modified for other research topics such as general academic research, chat bots, niche research, or anything requiring useful creative output and general autonomy. MOTO's novel brainstorming and rejection/validation stage allows autonomous long-term runtime without user intervention - if desired, research can be conducted for days or weeks without user input.

MOTO may produce many brilliant papers as it runs, these start-up papers are answers that rival traditional paid cloud deep research functions. As the user, observe MOTO as often or as little as you'd like - skip its autonomy and force it into final answer generation, or stop it early and select one of its highly creative pre-final answer papers. If the operator allows, let MOTO run for many hours and produce a final answer from its experimental mode, a final answer beyond the growing collection of related papers. In this mode, we have found quality can vary - however that is because MOTO is capable of autonomously deciding if it should output a shortform answer, like traditional cloud deep research - or whether to collect existing pre-final answer papers and write a long-form academic volume. With models over 131,000 token context limits, the harness is easily capable of producing final volumes with over 40,000 words, and MOTO produces this book-length content autonomously. It should be noted that this long-form answer is often so detailed that for any AI critique it requires the system to fully direct-inject the paper content. Providing an attempt at a novel 40,000 academic volume to a cloud agent using RAG (summarization-like techniques) may provide mixed results. MOTO strives to direct inject all content where possible. The built in “critique” feature allows the user to direct inject the full 40,000+ world volume into nearly any AI model of their choice. If the system decides to do a long form answer it will collect any relevant papers it has written, take only the best and related ones, organize them into chapters, write any gap papers, write the conclusion, and then lastly write the introduction chapter. This reverse order, body first, conclusion second, then introduction portion(s) last is crucial to allow MOTO the ability to be creative as it write. The traditional introduction -> body -> conclusion writing style creates Markovian constraints on the creative process. In other words, if the system wrote its introduction first, the body paragraphs are locked in and bound to the rules the introduction set. Writing the body section first gives the system greater freedom to discover as it writes as it is not bound by a detailed introduction. MOTO is an experimental system, the AI(s) are producing this content partially unguided and all papers should be judged with extreme scrutiny.

Give the program a try, MOTO is as cool as it sounds – there is a one-click installer. Use the two links below to download Python and Node.js, they should automatically install in seconds. Once those are downloaded, click the green “< > Code” drop-down menu on the top right of this GitHub page, download the zip file, extract it to your desktop then press launch.bat. Put in your OpenRouter.AI API key (or optionally connect LM studio for faster performance), select your agents in the settings profile – if desired and you are unsure you may use the preselected “fastest” profile.

Now you are set up and every time you press launch your home lab is ready for your prompt! Give MOTO the toughest question you can think of and press start to begin YOUR creations!

Created by Intrafere LLC | Donate | News & Updates

Outline of "MOTO - S.T.E.M. Mathematics Variant"

MOTO (Multi-Output Token Orchestrator) is a high-risk high-reward (novelty seeking AI) mathematics researcher designed to run for days at a time after pressing start without user interaction. This program can support multiple simultaneous models working in parallel from either local host LM studio, OpenRouter API key, or both.

Key Features

🤖 Autonomous Topic Selection, Brainstorming, and Paper Generation: AI chooses research avenues based on high-level goals and produces you a final answer with ZERO extra user input. Let MOTO run for days using the best models without touching it, or for a few hours using a faster draft model. How deep you research and how long it takes is left up to you, the user.
OpenRouter Integration: Supports both local (LM Studio) and cloud (OpenRouter) models. Use your local LM studio models ran offline from your computer or add your OpenRouter API key to compete and team up 3rd party models from the largest closed source LLMs like ChatGPT, Claude, DeepSeek, Gemini and Perplexity

🚀 Quick Start

Prerequisites

Before installation, you need:

Python 3.8+ - Download here
- ⚠️ IMPORTANT: Check "Add Python to PATH" during installation
Node.js 16+ - Download here
LM Studio (optional but HIGHLY recommended - otherwise your system will need to pay OpenRouter for RAG embedding calls, which is very slow compared to LM studio's local embeddings) - Download here
- If using open router, then download and load at least one model (e.g., DeepSeek, Llama, Qwen - older models and some models below 12 billion parameters may struggle, however it is always worth a try!)
- Load the LM Studio RAG agent [optional but HIGHLY recommended for much faster outputs/answers]: Load the embedding model nomic-ai/nomic-embed-text-v1.5 in your LM studio "Developer" tab (server tab) (search for "nomic-ai/nomic-embed-text-v1.5" to download it in the LM studio downloads center). Please note: you may need to enable "Power User" or "Developer" to see this developer tab - this server will let you load the amount and capacity of simultaneous models that your PC will suport. In this develop tab is where you load both your nomic-ai embedding agent and any optional local hosted agents you want to use in the program (I.e. GPT OSS 20b, DeepSeek 32B, etc). If you do not not download LM studio and enable the Nomic agent the system will run much slower and cost a slightly more due to having to use the paid service OpenRouter for RAG calls.
- Start the local server (port 1234)
If using cloud AI - Get an OpenRouter API key: Sign up at OpenRouter.ai and get a paid or free API key to use the most powerful cloud models available from your favorite providers. OpenRouter may also offer a certain amount of free API calls per day with your account key. When you download the MOTO deep research harness, you can see which models are free by checking the "show only free models" check box(es) in the MOTO app settings.

Installation

Windows (One-Click Launcher)

Clone or download this repository
Start LM Studio and load your models and "nomic-embed-text-v1.5" agent and/or enter OpenRouter API key
Double-click launch.bat
The launcher will:
- Check all prerequisites
- Install Python and Node.js dependencies automatically
- Create necessary directories
- Start backend and frontend servers
- Open the UI in your browser

That's it! The system will be running at http://localhost:5173

Manual Installation (All Platforms)

# Clone the repository
git clone https://github.com/Intrafere/MOTO
cd moto-math-variant

# Install Python dependencies
pip install -r requirements.txt

# Install frontend dependencies
cd frontend
npm install
cd ..

# Create necessary directories
mkdir -p backend/data/user_uploads
mkdir -p backend/logs

# Start the backend (in one terminal)
python -m uvicorn backend.api.main:app --host 0.0.0.0 --port 8000

# Start the frontend (in another terminal)
cd frontend
npm run dev

Then open http://localhost:5173 in your browser.

📖 Usage Guide

Mode 1 - Autonomous Mode (multi-paper writer):

Go to Autonomous Research tab
Enter high-level research goal (e.g., "Solve the Langlands Bridge problem")
Configure model settings for all roles
Click Start Autonomous Research
System will:
- Autonomously select research topics
- Build brainstorm databases
- Generate complete papers
- Create final answer synthesis (after 5 papers)

Mode 2 - Single Paper Writer (advanced/manual mode):

Mode 2, step 1: Aggregator (Knowledge Building)

Go to Aggregator Interface tab
Enter your research prompt (e.g., "Explore connections between modular forms and Galois representations")
Configure settings:
- Select submitter and validator models
- Set context window sizes (default: 131072 tokens)
- Configure 1-10 submitters (default: 3)
Click Start Aggregator
Monitor progress in Aggregator Logs tab
View accepted submissions in Live Results tab

Mode 2, step 2: Compiler (Paper Generation)

Go to Compiler Interface tab
Enter compiler-directing prompt (e.g., "Build a paper titled 'Modular Forms in the Langlands Program'")
Configure settings:
- Select validator, high-context, and high-parameter models
- Set context windows and output token limits
Click Start Compiler
Watch real-time paper construction in Live Paper tab
Monitor metrics in Compiler Logs tab

🛠️ System Architecture

Technology Stack

Backend: Python 3.8+, FastAPI, Uvicorn
Frontend: React, Vite, Tailwind CSS
AI: LM Studio API, OpenRouter API
RAG: ChromaDB, Nomic Embeddings, or OpenRouter embeddings fallback if LM studio is unavailable (not recommended - slower).
WebSocket: Real-time updates

Key Components

RAG System: 4-stage retrieval (query rewriting, hybrid recall, reranking, packing)
Multi-Agent Coordinator: Manages parallel submitters and sequential validation
Context Allocator: Direct injection vs RAG routing based on token budgets
Workflow Predictor: Predicts next 20 API calls for boost selection
Boost Manager: Selective task acceleration with OpenRouter

📁 Project Structure

moto-math-variant/
├── backend/
│   ├── aggregator/          # Tier 1: Multi-agent knowledge aggregation
│   ├── compiler/            # Tier 2: Paper compilation and validation
│   ├── autonomous/          # Tier 3: Autonomous topic selection and synthesis
│   ├── api/                 # FastAPI routes and WebSocket
│   ├── shared/              # Shared utilities, models, API clients
│   └── data/                # Persistent storage (databases, papers, logs)
├── frontend/
│   └── src/
│       ├── components/      # React components for UI
│       └── services/        # API and WebSocket clients
├── .cursor/
│   └── rules/               # AI agent design specifications (full system documentation)
├── launch.bat               # One-click Windows launcher
├── launch.ps1               # PowerShell launcher
├── requirements.txt         # Python dependencies
└── package.json             # Node.js dependencies

⚙️ Configuration

Model Selection

Aggregator:

1-10 submitters (configurable, default 3)
Each submitter can use different models
Single validator model (for coherent Markov chain)

Compiler:

Validator model (coherence/rigor checking)
High-context model (outline, construction, review)
High-parameter model (rigor enhancement)

Autonomous Research:

All aggregator and compiler roles configurable
Separate models for topic selection, completion review, etc.

OpenRouter Integration

Each role supports:

Provider: LM Studio (local) or OpenRouter (cloud)
Model Selection: Choose from available models
Host/Provider: Select specific OpenRouter provider (e.g., Anthropic, Google)
Fallback: Optional LM Studio fallback if OpenRouter fails

Context and Output Settings

All configurable per role:

Context Window: Default 131072 tokens (user-adjustable)
Max Output Tokens: Default 25000 tokens (recommended for reasoning models)

🔧 Troubleshooting

Installation Issues

"Python not recognized"

Reinstall Python and check "Add Python to PATH"
Verify: python --version in terminal

"Node not recognized"

Install Node.js from nodejs.org
Verify: node --version in terminal

"pip install failed"

Check internet connection
Try: python -m pip install --upgrade pip
Run as administrator if permission errors

Runtime Issues

"Failed to connect to LM Studio"

Ensure LM Studio is running
Start the local server in LM Studio (port 1234)
Load at least one model
Load embedding model: nomic-ai/nomic-embed-text-v1.5

"Port already in use"

Close other apps using ports 8000 or 5173
Restart computer if needed
Use different ports in config

High rejection rate

Check models are generating valid JSON
Review validator reasoning in logs
Ensure prompt is clear and specific
Use larger models for better results
View the learning curve analysis on the Intrafere.com website and ensure you are not just at a learning curve wall - 100's of rejections in a row before the first acceptance in the brainstorming session can be common.

System running slow

Use faster/smaller models
Reduce context window size
Close resource-intensive apps
Check RAG cache performance in logs

Common Error Messages

"ChromaDB corruption detected"

Delete backend/data/chroma_db folder
Restart the system (launcher cleans ChromaDB automatically)

"Context window exceeded"

Reduce context size in settings
System will automatically offload to RAG
Check logs for detailed token usage

JSON and output errors

Monitor your model(s) output(s) occassionally to see if its stuck in output loops and is repeatedly utilizing its entire output token budget - this is a sign the model runtime instance from either LM Studio or OpenRouter has corrupted. If this is the case you will either need to Switch OpenRouter hosts for that model, switch models, or if using LM studio you must unload and reload the model. However if this happens once, it is likely to happen again so you should either try to switch hosts (if using OpenRouter), switch runtime engines (if using LM studio), or switch models entirely as some models may be more vulnerable to this than others. This issue does not appear to be related to MOTO harness and the MOTO developers have no control over this deterministic model-loop corruption state. The repetitive nature of the harness appear to stress certain engines, for example when using AMD comptable engines, ROCm may have more instabilities than Vulkan as of 1/11/2026. This is an odd bug and it is unclear if this is related to the 3rd party runtime engine's K/V caching mechanism or some other feature of the code. If you find any information on this bug please submit it to the GitHub.

JSON truncation errors

Ensure you are not experiencing the output error looping mentioned above that some LLM runtime engines seem to experience, if your JSON truncation is not a result of looping then you should try increasing your models max output tokens. It is highly likely that your model was truncated because you did not set enough output tokens (20% or more of your token budget being allotted for token output is standard practice, longer thinking models like DeepSeek V3.2 Speciale may require much larger splits such as (164K total tokens, 64K reserved for output tokens), however most models function great closer to the 20% output budget mark.

📚 Documentation

QUICKSTART.md: Step-by-step setup guide
START_HERE.txt: Quick reference and prompting tips
.cursor/rules/: Complete system design specifications
- part-1-aggregator-tool-design-specifications.mdc
- part-2-compiler-tool-design-specification.mdc
- part-3-autonomous-research-mode.mdc
- rag-design-for-overall-program.mdc
- program-directory-and-file-definitions.mdc

🤝 Contributing

Contributions are welcome! Please:

Fork the repository
Create a feature branch (git checkout -b feature/YourFeature)
Commit your changes (git commit -m 'Add YourFeature')
Push to the branch (git push origin feature/YourFeature)
Open a Pull Request

Development Setup

For development with AI assistance:

Install Cursor - AI-powered IDE
The .cursor/rules/ folder contains complete design specifications
Cursor can help you understand and modify the system

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Intrafere LLC - Creator and maintainer
LM Studio for local model hosting
OpenRouter for cloud model access
Nomic AI for embedding models
ChromaDB for vector storage
FastAPI and React frameworks

⚠️ Disclaimer

Papers generated by this system have not been peer-reviewed and were autonomously generated without user oversight beyond the original prompts. Content may contain errors. Papers often contain ambitious content and/or extraordinary claims - all content should be viewed with extreme scrutiny. All users must follow terms of service, conditions, etc from all 3rd party applications.

🔗 Links

Website: https://intrafere.com
Program Info: https://intrafere.com/moto-autonomous-home-ai/
News & Updates: https://intrafere.com/moto-news/
Donate: https://intrafere.com/donate/
Documentation: See .cursor/rules/ folder
Issues: https://github.com/Intrafere/MOTO/issues
LM Studio: https://lmstudio.ai/
OpenRouter: https://openrouter.ai/
Cursor IDE: https://cursor.com/

📊 System Requirements

Minimum

OS: Windows 10+, macOS 10.15+, Linux
RAM: 16GB (for running local models)
Storage: 10GB free space
Internet: Required for package installation and OpenRouter

Name		Name	Last commit message	Last commit date
Latest commit History 13 Commits
.cursor/rules		.cursor/rules
backend		backend
frontend		frontend
(Do not edit)Known Bugs - Fixes in Progress.txt		(Do not edit)Known Bugs - Fixes in Progress.txt
.gitignore		.gitignore
CONTRIBUTING.md		CONTRIBUTING.md
INSTALL.md		INSTALL.md
LICENSE		LICENSE
QUICKSTART.md		QUICKSTART.md
README.md		README.md
START_HERE.txt		START_HERE.txt
launch.bat		launch.bat
launch.ps1		launch.ps1
package.json		package.json
requirements.txt		requirements.txt
startup.ps1		startup.ps1
startup.sh		startup.sh
verify_update.py		verify_update.py

License

Intrafere/MOTO

Folders and files

Latest commit

History

Repository files navigation