Add recursive transformer model to foundry

[drQedwards]

Here's the updated version of your model information, fully adapted for the Recursive Transformer Model (RTM) with ERS (Enhanced Reconsideration System). It keeps the same professional structure and tone as the original UI-TARS example while accurately reflecting what your HF repo and research actually contain.

Updated Model Information

Model Name: Recursive Transformer Model (RTM) + ERS
Hugging Face URL: https://huggingface.co/Drjkedwards/Recursive-Transformer-Model
Model Type: Stateful Memory & Reconsideration Framework for Transformers
Architecture: Custom PyTorch (PMLLLattice + Recursive Reconsideration) – extends any Transformer
Parameters: Not a fixed-parameter LLM (lightweight lattice; runs on top of existing embedding models)
License: MIT (core ERS implementation)

Use Case

The Recursive Transformer Model (RTM) with the Enhanced Reconsideration System (ERS) is a novel architectural extension that transforms stateless Transformers and LLMs into stateful, self-correcting systems.

It is specifically designed for:

• Long-term memory coherence in agents and chatbots
• Automatic detection and resolution of contradictory or outdated beliefs (“nostalgic incorrectness”)
• Persistent memory management across inference sessions
• Integration with knowledge graphs (Graphiti, Mem0) and agent frameworks (LangChain, etc.)
• Recursive multi-pass reasoning with temporal decay and consensus voting

Performance

• Core Strength: Successfully resolves synthetic contradictory memory scenarios through iterative reconsideration loops
• Key Metrics (Conceptual): Nostalgic Incorrectness (NI) reduction, confidence delta tracking, contradiction detection score, cosine similarity shifts in embedding space
• Efficiency: Low overhead when integrated with existing embedding models (e.g., sentence-transformers). Recursive passes add controllable compute cost.
• Qualitative Results: Demonstrates coherent state maintenance and belief updating in controlled memory tests (see TechRxiv paper for examples such as conflicting “Paris” facts).

No large-scale public benchmarks (e.g., OSWorld, ScreenSpot) are available yet, as this is a memory layer/framework rather than a standalone generative VLM or LLM.

Why Azure AI Foundry? (or any enterprise platform)

• Agentic AI Enhancement: Turns stateless LLMs/agents into stateful systems with persistent self-correction — ideal for reliable long-running agents.
• Enterprise Demand: Growing need for trustworthy memory in autonomous agents, knowledge-intensive applications, RPA, and safety-critical AI systems.
• Open Source: MIT license supports broad adoption and integration.
• Complementary: Works alongside large foundation models (e.g., Azure OpenAI, Llama, Qwen) to add long-term coherence and contradiction resolution without replacing the base model.
• Hybrid Potential: Can be combined with vision-language models or GUI agents for more reliable multi-step reasoning and memory grounding.

Technical Requirements

Deployment Type: Python library / custom PyTorch model (can be deployed as part of any Transformer pipeline)
Hardware: Standard CPU or GPU (PyTorch-compatible). No large VRAM requirement for the lattice itself.
Framework: PyTorch + Transformers (custom modeling file)
Dependencies: sentence-transformers, safetensors, optional: mem0-ai, graphiti-core, LangChain
Integration: Use RecursiveTransformerModel.from_pretrained(...) with trust_remote_code=True

Community Interest

• Downloads: Growing via linked Kaggle PyTorch model and GitHub ERS repository
• Research Interest: TechRxiv preprint (October 2025) introducing the architecture and Persistent Memory Logic Loops (PMLL)
• Related Work: Hybrid TRM-RTM models, Topic Integrator for recursive context annotation
• Use Cases: Agent memory management, belief updating in conversational AI, long-term knowledge consistency in autonomous systems, research on mitigating hallucination-style memory errors

Additional Context

• Developed by: Dr. Josef “Q.” Edwards (University of Colorado Boulder)
• Core Innovation: Persistent Memory Logic Loops (PMLL) + adaptive temporal decay + consensus-based contradiction detection
• Not a standalone LLM: This is a memory augmentation layer that can be integrated with any embedding-based Transformer (including VLMs for multimodal memory).
• Repository Contents: Custom RecursiveTransformerModel, PMLLLattice, MemoryBlock, config, and example weights.
• Linked Resources:
  • GitHub ERS Library: https://github.com/drqedwards/ERS
  • Kaggle PyTorch Implementation: https://www.kaggle.com/models/josefedwards/recursive-transformer-model/pyTorch
  • TechRxiv Paper: https://www.techrxiv.org/users/856117/articles/1345789 (or ResearchGate version)

---

This version is accurate, professional, and highlights the strengths of RTM/ERS without overstating capabilities (e.g., no fake GUI automation benchmarks).

Would you like a shorter “one-paragraph” summary for the HF model card description, or a version optimized for a specific audience (e.g., enterprise sales, research paper appendix, or Azure proposal)? I can refine it further.

References

RT, GitHub: https://github.com/drqedwards/ppm
TRM Paper: (https://arxiv.org/abs/2510.04871)
Website: https://drqsatoshin.com
Thank you for considering this request!