List of AI Smartness Techniques

AI Smartness Techniques

Making an AI system smarter isn't just about "training" anymore. That's only one of the many ways. You can also make an LLM smarter by giving it better information to work with at runtime (e.g., RAG, plug-ins, etc.), or allowing it to use better tools (e.g., calculators, clocks, etc.). Giving it more time to think at inference time is another way, which is called "test time compute". Prompt engineering is simple and underrated.

Anyway, here's the list so far:

List of Top-Level Approaches for a Brainy AI Application:
1. Training
2. Fine-tuning
3. PEFT (e.g., LoRA)
4. Test-time compute (inference budget)
5. Augmentation approaches (RAG or RALM)
6. Dynamic data augmentation (plugins, search, etc.)
7. Tool usage ("function calling")
8. Hooks for tools
9. In-Context Learning (ICL) (is a fancy term for "use examples when prompting")
10. Prompt engineering
11. Context engineering
12. Reasoning models (one-shot)
13. Latent space reasoning approaches (e.g., concept tokens)
14. Multi-step reasoning models
15. Deep research models
16. Next-generation reasoning models (e.g., LCMs)
17. Next-generation model architectures (e.g., SSMs)
    
    Training Methods:
18. Pre-training
19. Reinforcement Learning (RL)
20. Reinforcement Learning from Human Feedback (RLHF)
21. Reinforcement Learning from AI Feedback (RLAIF)
22. Supervised Fine-Tuning (SFT)
23. Direct Preference Optimization (DPO)
24. Proximal Policy Optimization (PPO)
25. Group Relative Policy Optimization (GRPO)
26. Reasoning-specific training
27. Gradient optimizers
28. Training resiliency improvements
29. Federated Learning
30. Distributed training
31. Incremental learning
32. Continual learning
    
    Training Data Sets:
33. Common crawl dataset
34. Reasoning datasets
35. Synthetic data
36. Synthetic data augmentation (e.g., synonymization)
    
    Preparing Training Data:
37. Data deduplication
38. Personal identifying information (PII) removal
39. Data formatting and conversion
40. PDF document usage
41. Legal rights confirmation
    
    Fine-Tuning:
42. Basic fine-tuning (brute-force)
43. Full-parameter fine-tuning (naive fine-tuning)
44. Unsloth efficient fine-tuning
45. Post-Optimization Fine-Tuning (POFT) (e.g., after quantization)
    
    Parameter-Efficient Fine-Tuning (PEFT):
46. LoRA (low-rank matrices)
47. Multi-LoRA
48. QLoRA (quantized LoRA adapters)
    
    Knowledge Distillation:
49. Knowledge distillation (teacher-student methods)
50. White-box knowledge distillation
51. Black-box knowledge distillation
52. Ensemble knowledge distillation (multi-teacher)
    
    Advanced Model Creation Methods:
53. Model merging
54. Submodel extraction
    
    Multi-Model Methods:
55. Mixture-of-Experts (MoE)
56. Shared experts (MoE)
57. Model selection algorithms
58. Big-little model architectures
59. Model routing algorithms
    
    Prompt/Context Augmentation Strategies:
60. RAG architectures
61. RALM architectures
    
    General Architectures:
62. Multi-agent architectures
63. Compound AI (multiple LLM and non-LLM components)
    
    RAG Popular Architectures:
64. Basic RAG (with database of document chunks)
65. Keyword lookup (e.g., BM25)
66. Semantic lookup (embedding models)
67. Vector databases
68. Packing methods
69. Reranker optimizations
    
    Advanced RAG Architectures:
70. Graph RAG
71. Ontology RAG (taxonomies)
72. Agentic RAG (retrieval and/or actions)
73. RAG dynamic tool usage
74. RAG database plugins (SQL query data)
75. Table-Augmented Generation (TAG)
76. RAG search plugins (e.g., internet search)
77. Long context RAG (big chunks!)
78. MiniRAG architectures
79. MegaRAG architectures
    
    Data Source Integrations:
80. Plugins
81. Internet search plugins
82. Database query integrations
    
    Tool Integrations:
83. Basic tools (e.g., clocks, calculators, etc.)
84. TALM architectures
85. Heuristic non-LLM tools
    
    Tool "Hook" Integrations:
86. "Hooks" (for prompt preprocessing tools)
87. Heuristic non-LLM tool hooks
    
    LLM Long-Term Memory:
88. Basic LLM memory recall
89. Personalization
    
    Agent Integrations:
90. MCP
91. Multi-agent architectures
    
    Prompt Auto-Optimization:
92. LLM prompt optimization
93. Programmatic prompting
    
    Prompt Engineering:
94. Basic prompt engineering techniques
95. System prompts
96. Emotional prompting
97. Exemplars (putting examples in prompt context)
    
    Reasoning Prompt Engineering:
98. Chain-of-Thought (CoT) one-shot
99. "Step by Step"
100. Metaprompting
101. "Longer answers" one-shot reasoning (thinking to oneself)
102. Implicit reasoning models
     
     Multi-Step Reasoning (Test-Time Compute):
103. Chain-of-Thought (multi-step versions)
104. Chain-of-Draft (CoD)
105. Tree-of-Thought
106. Tree-structured CoT (other variants)
107. Reflection (LLM self-evaluation)
108. Concise Chain-of-Thought
109. Constrained Chain-of-Thought
110. Hidden Token Chain-of-Thought
111. Continuous Chain-of-Thought ("Coconut")
112. LLM-as-Judge
113. Best-of-N reasoning
114. Skeleton-of-Thought
115. ReAct (Reason-and-Act)
     
     Advanced Multi-Step Reasoning Approaches:
116. Large Reasoning Models
117. Small reasoning models
118. Hybrid reasoning models (combining fast and slow reasoning)
119. System 2 thinking
120. Graph reasoning
121. Fast-slow reasoning
122. Planning (in multi-step reasoning inference)
123. Deep Research Models
     
     Theoretical Reasoning Approaches:
124. Advanced Generative Intelligence (AGI) (human-level)
125. Advanced Super-Intelligence (ASI)
126. Overthinking
127. Underthinking
128. Temporal reasoning
     
     Context Engineering:
129. GUI agents
130. Computer usage models
     
     Poor Answer Mitigation:
131. Alignment
132. Refusal modules
133. Prompt shield
134. Jailbreak mitigations
135. Bias mitigations
136. Hallucination reduction methods
137. Guardrails
     
     Decoding Algorithm Improvements:
138. Beam search decoding
139. Constrained decoding
140. CoT decoding (mimicking CoT in decoding)
141. Speculative decoding (multi-path)
142. Multi-token prediction (MTP)
143. Decoding penalties (disallowed words/phrases)
     
     Addressing Common LLM Limitations:
144. Basic arithmetic
145. Mathematical reasoning
146. Common sense
147. 3D worldview
148. 2D spatial reasoning
149. Sarcasm detection
150. Humour
151. Gullibility
152. Sycophancy (excessive alignment)
153. Embodied AI (physical AI)
     
     Weird AI Intelligence Methods:
154. Subliminal learning
155. Attention steering
156. Prompt tuning
157. Activation patching
     
     Next-Generation Reasoning Approaches:
158. Multimodal reasoning models
159. Vision reasoning models
160. Large Concept Model (LCM)
161. Program synthesis models
162. Symbolic execution models
163. Symbolic logic reasoning
164. Concept tokens
165. Reasoning tokens
166. Soft prompts
167. Gist tokens
168. Knowledge graphs
169. Ontology-based reasoning
170. Tabular-data reasoning
     
     Old-Generation Reasoning Approaches (Reuse & Recycle):
171. Rule-based AI
172. Expert systems
173. Fuzzy logic systems
174. Inductive reasoning
175. Deductive reasoning
176. Heuristic reasoning methods
     
     Next-Generation Model Architectures (Candidates for a Post-LLM World):
177. State Space Model (SSM)
178. Mamba
179. Hyena
180. RWKV models
181. Liquid AI
182. Next-generation AI architectures (various)
     
     Multi-Model Intelligence:
183. Ensemble inference
184. Collaborative inference
185. Best-of-N
186. Swarm intelligence
187. Inverse Models
188. Multi-Mini Model (MMM)

AI Books from Aussie AI

The Sweetest Lesson: Your Brain Versus AI: new book on AI intelligence theory: Your brain is 50 times bigger than the best AI engines. Truly intelligent AI will require more compute! Another case of the bitter lesson? Maybe it's the opposite of that: the sweetest lesson. Get your copy from Amazon: The Sweetest Lesson

RAG Optimization: Accurate and Efficient LLM Applications: new book on RAG architectures: Smarter RAG Faster RAG Cheaper RAG Agentic RAG RAG reasoning Get your copy from Amazon: RAG Optimization

Generative AI Applications book: Deciding on your AI project Planning for success and safety Designs and LLM architectures Expediting development Implementation and deployment Get your copy from Amazon: Generative AI Applications

Generative AI programming book: Generative AI coding in C++ Transformer engine speedups LLM models Phone and desktop AI Code examples Research citations Get your copy from Amazon: Generative AI in C++

CUDA C++ Optimization book: Faster CUDA C++ kernels Optimization tools & techniques Compute optimization Memory optimization Get your copy from Amazon: CUDA C++ Optimization

CUDA C++ Debugging book: Debugging CUDA C++ kernels Tools & techniques Self-testing & reliability Common GPU kernel bugs Get your copy from Amazon: CUDA C++ Debugging

More AI Research Topics

Read more about:

• « Aussie AI Blog Index
• Inference Optimizations
• List of Optimization Techniques
• AI Research Home