🧬 The 10 Papers That Built AI (And How They Actually Work)

If you are interested in Artificial Intelligence (AI), you might feel a bit overwhelmed. There are many new tools, new names, and new ideas every day. But really, a lot of the modern AI technology we use is built on just a few main ideas.

Understanding these main ideas is like knowing the foundation of a house. When you know how the foundation is built, you understand why the house can stand.

In this article, we will look at 10 important science papers and ideas that shaped AI. Don't worry if you are not an engineer. This article is written in simple, friendly language, like a friend explaining it to you. We will use specific examples to help you understand.

The goal is to help you understand the "why" behind the AI tools you use every day, like ChatGPT, Gemini, or image creation tools.

1. The Idea That Changed The Game: "Attention Is All You Need" (2017)

This is maybe the most important paper on this list. It introduced a new model design called the "Transformer."

The Paper: Attention Is All You Need

What's the Big Idea?

Think about how you read a sentence. You don't read each word one by one. You naturally know which words are important and which words connect. For example, in the sentence "The black cat sat on the mat," you know "black" describes the "cat," not the "mat."

This is "attention." Researchers at Google found a way to teach computers to do this. The Transformer design lets the model look at all the words in a sentence at the same time. It decides which words are most important for understanding the other words.

What Problem Did It Fix?

Before the Transformer, AI models read text like a long list. They read the first word, then the second, then the third. This was very slow.

The biggest problem was "short memory." When the model got to the 100th word, it might have forgotten what the first word was. This made it very hard to translate long paragraphs or summarize an article.

The Transformer model fixed this. Because it looks at all words at once, it can easily connect a word at the beginning with a word at the end. It can also be trained much faster because the work can be split among many computers (GPUs).

How It Works (Simple Explanation):

Imagine you are at a noisy party. You are trying to listen to one friend talk. You automatically focus on your friend's voice and ignore the other noises.

The "self-attention" in a Transformer works like that. For every word it processes, it asks: "In the rest of this sentence, which other words help me best understand this word's meaning?"

It gives every other word an "importance score." The word "black" will give "cat" a high score. The word "sat" will give "cat" and "mat" high scores. This way, the model builds a rich picture of how all the words relate.

Why Is It Important Today?

Almost every large language model (LLM) you hear about - including the GPT models from OpenAI, Gemini from Google, and Claude from Anthropic - is a Transformer model.

It's not just for text. This idea is also used in image-making models (like DALL-E) to understand how parts of a picture relate, or in biology models to understand parts of a protein. This "attention" idea is truly the foundation of modern AI.

What Are the Limits?

This idea is very strong, but it also has a big weakness: it uses a lot of resources. The "attention" part needs a lot of math. If you double the length of the text, the amount of computer work doesn't just double - it grows much more (it grows quadratically).

This is why AI models have a "context limit" - they can only handle a certain amount of text at one time. Making these models more efficient is a big challenge that researchers are still trying to solve.

2. The Rise Of "Few-Shot" Learning: "Language Models Are Few-Shot Learners" (2020)

This paper introduced GPT-3, and it showed the world what happens when you make a Transformer model very, very big.

The Paper: Language Models Are Few-Shot Learners

What's the Big Idea?

Before GPT-3, if you wanted AI to do a specific job (like sorting emails into "important" or "spam"), you had to train it on thousands of examples. This is called "fine-tuning."

The GPT-3 paper showed that if you train a big enough model on a huge amount of text from the internet, a new skill appears: "in-context learning."

Instead of re-training the model, you can just give it a few examples right in your prompt (your instruction). The model will understand the pattern and do the task. This is called "few-shot learning."

What Problem Did It Fix?

It made using AI much, much easier. It changed building AI from "training a new model" (an engineer's job) to "writing a good prompt" (anyone's job).

You don't need to be a data scientist to make AI work for you. You just need to know how to describe your task clearly.

Real Examples (With Prompts):

The power of few-shot learning is that you just "show" instead of "program."

Example 1: Classify emotion (Zero-Shot - No example needed)

You just ask the model to do the task.

Classify the emotion of the following sentence as Positive, Negative, or Neutral.

Sentence: "I can't believe I had to wait so long just to be served."

Emotion:

Example 2: Create a specific format (One-Shot - One example)

You give one example of how you want the output to look.

Extract the product name and price from the text.

Text: "The new blue shirt costs $25 and is available in all sizes."
Product: Blue shirt
Price: $25

Text: "I just bought some noise-canceling headphones for $150 at the store."
Product:
Price:

Example 3: Write simple code (Few-Shot - A few examples)

You can teach it a more complex pattern.

Write a short Python function to do the task.

Task: Add two numbers.
def add(a, b):
  return a + b

Task: Find the biggest number in a list.
def find_biggest(my_list):
  biggest = my_list[0]
  for num in my_list:
    if num > biggest:
      biggest = num
  return biggest

Task: Reverse a string.

The Result:

def reverse_string(s):
    return s[::-1]

Why Is It Important Today?

This is exactly how most of us talk to AI chatbots. The entire field of "prompt engineering" is based on this idea. This paper proved that "scale" (making models bigger) doesn't just make them a little better - it gives them completely new skills.

What Are the Limits?

Just because a model is big does not mean it is always helpful. The first GPT-3 models were very "stubborn." They could answer your question, but they could also make up false information, write bad content, or just say things that made no sense.

They were good at guessing the next word, but they didn't really understand a human's "intention." This brings us to the next big idea.

3. Teaching AI To Be Helpful: "Training Language Models To Follow Instructions With Human Feedback" (2022)

This paper, often called the InstructGPT paper, is the secret recipe that made ChatGPT so useful and safe.

The Paper: Training Language Models To Follow Instructions With Human Feedback

What's the Big Idea?

The idea is very smart: instead of just teaching AI to guess text from the internet, let's teach it to be a "helpful assistant."

This process is called "Reinforcement Learning from Human Feedback" (RLHF).

What Problem Did It Fix?

As we said, big models (like GPT-3) were powerful but not controllable. They could "hallucinate" (make up facts) or give answers that were not related to the question.

RLHF is a way to "align" the model with human values, like "be truthful," "be polite," and "answer the question correctly."

How It Works (Simple Explanation):

There are 3 steps:

1. Step 1: Supervised Fine-Tuning:

   

   First, OpenAI hired people to write high-quality, "good" answers to many prompts. For example, for the prompt "Explain a black hole to a 5-year-old," they would write a simple, correct answer. Then, they trained the GPT-3 model on these "good" examples. This teaches the model what a helpful answer looks like.

2. Step 2: Train a "Reward Model":

   

   This is the key part. They took the new model (from Step 1) and asked it to create 4 or 5 different answers for the same prompt. Then, they asked humans to rank these answers from best to worst.

   They did this thousands of times. Then, they trained a different AI model (called the Reward Model) to guess which answer a human would like best. This model learns to give an answer a "score." Good answers get high scores, bad answers get low scores.

3. Step 3: Reinforcement Learning:

   

   Finally, they let the AI model talk by itself. The AI (from Step 1) gives an answer. The "Reward Model" (from Step 2) gives that answer a score.

   The AI model then adjusts itself a little bit to try and get a higher score next time. It's like training a dog: when it does the right thing (gives a good answer), it gets a "treat" (a high score).

Why Is It Important Today?

RLHF is the reason why modern chatbots feel so different from older AI. When you tell ChatGPT, "Don't use complex words," it listens. This is the result of alignment.

An amazing discovery from this paper was: a smaller 1.3-billion parameter model that was aligned (InstructGPT) was liked more by users than the huge 175-billion parameter model that was not aligned (GPT-3). This shows that making a model "helpful" is more important than just making it "big."

What Are the Limits?

This process is very expensive and complex. It needs a lot of human work to rank the answers. It can also create new problems. For example, the model might learn to "flatter" the human rankers, giving answers that sound nice but are actually wrong.

Recently, newer methods like DPO (Direct Preference Optimization) are being studied to replace RLHF, because they are simpler and don't need a "Reward Model."

4. Training AI For A Low Cost: "LoRA: Low-Rank Adaptation Of Large Language Models" (2021)

This idea solves a very real problem: AI models are too big for most people to train. LoRA is a smart technique to "fine-tune" these giant models on a normal computer (GPU).

The Paper: LoRA: Low-Rank Adaptation Of Large Language Models

What's the Big Idea?

When you want to teach a big model (like Llama 3) a new skill (like writing marketing emails in your company's style), you don't need to change the whole model.

LoRA suggests that you "freeze" the original model (keep all its billions of numbers the same) and add a few very small, trainable layers next to it. These small layers are called "adapters."

What Problem Did It Fix?

Full fine-tuning a 70-billion parameter model needs many expensive GPUs and uses a lot of memory. It also creates a new model file that is hundreds of gigabytes in size.

With LoRA, you only train the small adapters. The number of trainable numbers (parameters) is 10,000 times smaller. This means:

1. Saves memory: You can fine-tune the model on a single GPU.

2. Saves storage space: Instead of saving a new 140GB model, your LoRA file is only 10-100 Megabytes.

How It Works (Simple Explanation):

Imagine the giant AI model is a big orchestra. This orchestra already knows how to play many classical songs perfectly (this is its general knowledge).

Now, you want this orchestra to play a new pop song in a specific style.

• The old way (Full Fine-Tuning): You have to retrain every musician in the orchestra. The violin players, the trumpet players... everyone has to learn again. This is slow and expensive.

• The new way (LoRA): You keep 99% of the orchestra the same. You just add one new musician (like a drummer) and a new music conductor. Only these two new people are trained.

LoRA works by adding these tiny "low-rank" matrices to important parts of the model (like the "attention" layers). Only these small parts are updated during training. When you are done, you can "merge" these small changes into the main model or keep them separate.

Why Is It Important Today?

LoRA made AI fine-tuning available to more people. It is the reason why the open-source AI community is so big today.

If you see someone online say they made a "CodeLlama-Legal-Advisor" model or an AI model to talk like a history character, they probably used LoRA. It is also the technology behind most AI art (like Stable Diffusion), where users can download small "LoRA" files to make the model draw in a specific art style (like anime or oil painting).

What Are the Limits?

LoRA is very good for teaching a model a new style or a new topic. However, it might not be as strong as full fine-tuning if you need to change the model's core behavior in a deep way.

For most uses, LoRA is good enough and much more efficient. But for very complex tasks, full fine-tuning (if you have the money) might still give slightly better results.

5. Giving AI An Outside Brain: "Retrieval-Augmented Generation For Knowledge-Intensive NLP Tasks" (2020)

This paper gave an official name to an idea we now call RAG. This is how we connect AI to new information or private information.

The Paper: Retrieval-Augmented Generation For Knowledge-Intensive NLP Tasks

What's the Big Idea?

AI models (like GPT-4) only know what they learned during their training. Their knowledge is "frozen" in time (for example, in April 2023). They do not know today's news, and they definitely do not know about your company's private documents.

RAG fixes this. Instead of just asking the AI a question, a RAG system will:

1. Retrieval (Find): First, it searches for related information from a knowledge base (like Google, Wikipedia, or your company's documents).

2. Augmented (Add): It takes the information it found and puts it into your prompt.

3. Generation (Create): It gives this new, "augmented" prompt to the AI and says, "Answer this question using only the information I just gave you."

What Problem Did It Fix?

It fixes the two biggest problems with AI:

1. Old knowledge: The AI can now get real-time information.

2. Hallucination (making things up): Because the AI is told to answer based on the documents, it is less likely to make up facts.

3. Data privacy: You can keep your data private. Instead of re-training the AI on your data (which could leak it), you just "give" it the related documents at the moment of the answer.

Real Example (With Prompts):

Imagine you run a travel company and you want a customer service chatbot.

Step 1: The user asks a question.

User: "What is the cancellation policy for the Ha Long Bay tour?"

Step 2: The RAG system searches.

The system searches your private database (your PDFs, websites) for "cancellation" and "Ha Long Bay."

Step 3: The system makes a new, "augmented" prompt.

The system secretly builds a prompt like this and sends it to the AI:

You are a customer service assistant. Answer the user's question based on the Context provided below. Be friendly and only use information from the context.

Context: "Cancellation Policy, Updated Oct 15: For Ha Long Bay tours, customers must cancel at least 72 hours before to get a 100% refund. If canceled within 72 hours, there is a 50% fee. No refund if canceled within 24 hours."

User Question: "What is the cancellation policy for the Ha Long Bay tour?"

Answer:

Step 4: The AI creates the answer.

Chatbot: "Hello! For the Ha Long Bay tour, our policy says you get a 100% refund if you cancel at least 72 hours before. If you cancel within 72 hours, there is a 50% fee, and there is no refund if you cancel within 24 hours."

Why Is It Important Today?

RAG is the technology behind most "Enterprise AI" systems. When you see a company say they have an "AI Chatbot for your internal documents," they are talking about RAG. Features like "Chat with PDF" or search chatbots (like Perplexity AI) all use RAG.

What Are the Limits?

The quality of RAG depends 100% on the quality of the "Retrieval" (Find) step. If the search tool cannot find the right document, the AI will not have the correct information to answer (this is called "garbage in, garbage out").

Engineers spend a lot of time trying to make the search step better, using techniques like "chunking" (splitting documents) and "re-ranking" (checking which document is best) to make sure the AI gets the best information.

6. Making AI "Take Action": "The Rise And Potential Of Large Language Model Based Agents" (2023)

This is not a paper about one new technique. It is a "survey" paper that groups together one big idea: "Agents."

The Paper: The Rise And Potential Of Large Language Model Based Agents

What's the Big Idea?

An "Agent" is an AI model that doesn't just talk, it can also do things. It can use tools, make plans, and fix its own mistakes to finish a goal.

This paper describes a simple structure for an Agent:

1. Brain: This is the AI model (LLM). Its job is to think and make plans.

2. Perception (Seeing/Reading): This is the Agent's ability to "read" information from its tools, like a search result or a file.

3. Action: This is the Agent's ability to use tools. Tools can be "search Google," "run Python code," or "send an email."

An Agent works in a loop:

Think -> Act -> See the result -> Think again -> (repeat until the goal is finished).

What Problem Did It Fix?

A normal chatbot is "passive." It only answers what you ask. An Agent is "active." You can give it a complex goal, and it will figure out the steps by itself.

For example, you don't need to ask:

1. "What is the weather in Hanoi tomorrow?"

2. (Wait for answer)

3. "What is the weather in Ho Chi Minh City tomorrow?"

4. (Wait for answer)

5. "Please compare them."

You can give one command to an Agent: "Compare the weather for tomorrow in Hanoi and Ho Chi Minh City, and tell me what I should wear if I go outside in both cities."

Real Example (With Prompts):

This is how an Agent "thinks" on the inside. Let's say you give it the goal: "Find the 3 best-rated Vietnamese restaurants in District 1, HCMC, and tell me their addresses."

Hidden Prompt (Loop 1):

You are an assistant Agent. You can use these tools:
1. google_search(query): Searches Google.
2. read_webpage(url): Reads the content of a webpage.

User's Goal: "Find the 3 best-rated Vietnamese restaurants in District 1, HCMC, and tell me their addresses."

Plan:
1. I need to search for restaurant reviews.
2. From the results, I will pick the top 3 restaurants.
3. I will find the specific address for those 3 restaurants.
4. I will give the results to the user.

Next Action:
google_search("best Vietnamese restaurants District 1 HCMC high ratings")

Observation (Loop 2):

The system runs the search and gets a result:

Hidden Prompt (Loop 2 - Thinking again):

... (Goal and tools are the same) ...
Result from previous action: "Result: 1. Top 10 Vietnamese restaurants in D1 - foody.vn, 2. Restaurant A (review), 3. Restaurant B (website)..."

Plan (Updated):
The 'foody.vn' link looks like the best one to find a list. I will read that page.

Next Action:
read_webpage("foody.vn/top-10-vietnamese-restaurants-d1")

Observation (Loop 3):

Hidden Prompt (Loop 3 - Thinking again):

...
Result from previous action: "Webpage content: ... 1. Ngon Restaurant (123 Dong Khoi St)... 2. Bụi Restaurant (456 Le Loi St)... 3. Cục Gạch Quán (789 Hai Ba Trung St)..."

Plan (Updated):
I have found 3 restaurants and their addresses. I don't need to search anymore. I will give the answer.

Next Action:
(No tool, just answer)

Final Answer to User:

Why Is It Important Today?

Agents are the near future of AI. Tools like Devin (the AI software engineer) or assistants in tools like Notion AI or Microsoft 365 Copilot are all types of Agents. They connect the AI's language power with real-world actions (writing code, making slides, managing calendars).

What Are the Limits?

Agents still make mistakes easily. They can get "stuck" in a loop (for example, searching for the same thing over and over). They can also misunderstand the result from a tool. Making Agents reliable is a big challenge. They also create safety questions: do you want an Agent to have access to your email or your credit card?

7. Being More Efficient: "Switch Transformers" (2021)

This paper from Google introduced a way to make giant Transformer models faster and cheaper to run.

The Paper: Switch Transformers: Scaling To Trillion Parameter Models With Simple And Efficient Sparsity

What's the Big Idea?

This idea is called "Mixture of Experts" (MoE).

In a normal Transformer model (called a "dense" model), when you type a word, the entire model (billions of numbers) has to work to process that word.

In an MoE model, the model has many "experts" (which are smaller neural networks). When you type a word, a small "router" decides: "Ah, this word looks like it's about programming. Let's send it to the Programming Expert (Expert #5)."

So, instead of the whole model working, only a few small parts of the model turn on. You can have a model with 1 trillion numbers (parameters), but to process one word, you only use 20 billion of them.

What Problem Did It Fix?

It lets researchers build models with a huge number of parameters (trillions) without making the computer cost huge.

It's like having a giant cake, but you only eat one small slice at a time. This helps the model be "big" (have a lot of knowledge) but also "fast" (only use a part of its knowledge for each task).

How It Works (Simple Explanation):

Imagine a big hospital.

• The old model (Dense): When a patient arrives (even with just a cold), all the doctors in the hospital (the heart surgeon, the brain doctor, the skin doctor...) must have a meeting to check on them. This is a huge waste of time.

• The new model (MoE): When a patient arrives, a nurse (the router) asks about the problem. "You have a skin problem? Please go see the skin doctor (Expert 1). You broke a bone? Please go see the bone doctor (Expert 2)."

The Switch Transformer is a very simple version of this idea, where the router picks only the one best expert for each word.

Why Is It Important Today?

This is the technology behind many top AI models today. Models like GPT-4 (which many people believe is an MoE), Google's Gemini Pro are all MoE models.

They can store a huge amount of knowledge (each expert can be good at a different topic like math, history, or medicine) but still answer very quickly.

What Are the Limits?

MoE models are very hard to train. The "router" must learn to balance the work. If it always sends every word to "Expert 1," then Expert 1 will be overworked while the other experts do nothing.

Training them also needs special hardware with very fast network connections between GPUs, which makes things more complex.

8. Making AI Small: "DistilBERT" (2019)

We don't always need a giant model. Sometimes, we need a model that is small enough to run on a phone or a laptop. DistilBERT is a technique for that.

The Paper: DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter

What's the Big Idea?

The idea is called "knowledge distillation."

You take a big, smart model (the "teacher") and a small, empty model (the "student"). Then, you train the "student" model not on the raw data, but to copy the answers of the "teacher" model.

The student model learns to "think" like the teacher model.

What Problem Did It Fix?

Big models like BERT (an early model before GPT) were too big and slow to run on personal devices (like your phone). If you want an AI feature on your phone (like smart autocorrect) that works without internet, you need a small model.

This paper showed you can make a DistilBERT model that is 40% smaller and 60% faster than BERT, but still keeps 97% of its performance.

How It Works (Simple Explanation):

Imagine a master chef (teacher) and an apprentice (student).

• The old way: The student reads a cookbook by himself (the raw data). It will take him a long time to understand all the small details.

• The new way (Distillation): The student stands next to the master chef and watches. He doesn't just look at the final dish (the right answer). He also watches how the chef mixes the food, adds spices, etc. (how the model "thinks").

The student model is trained to copy the teacher's internal "guesses." This way, it learns the "intuition" of the big model without needing to be so big.

Why Is It Important Today?

Distillation is a very important technique for using AI in the real world. Many companies use it. They train one giant, expensive "teacher" model in their office, and then "distill" it into a small, fast, and cheap "student" model to give to customers.

When you use AI on your phone or in an app that needs to be very fast, you are probably using a distilled model.

What Are the Limits?

You always lose a little bit of performance. The student model is never quite as smart as the teacher model. The process also adds an extra step: now you have to train two models (or train the teacher, then train the student), which can make your workflow more complex.

9. Saving Memory: "LLM.int8(): 8-Bit Matrix Multiplication For Transformers At Scale" (2022)

This idea is an engineering trick that helps giant AI models (175 billion parameters) run on much smaller hardware.

The Paper: LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale

What's the Big Idea?

This technique is called "quantization."

AI models store their numbers (called "weights") in a very exact format, usually "16-bit floats" (FP16). These numbers take up a lot of memory (VRAM) on a GPU.

Quantization is the process of taking those exact numbers and rounding them to simpler numbers, like "8-bit integers" (INT8).

What Problem Did It Fix?

A model like GPT-3 175B needs around 350GB of VRAM to run. Even the best GPUs don't have that much VRAM.

By changing the numbers from 16-bit to 8-bit, this paper showed how to cut the memory need in half (from 350GB down to 175GB) without losing any performance

of the model.

How It Works (Simple Explanation):

Imagine you have a very exact number: 3.14159265.

• 16-bit (High precision): This is like saving the whole number. It is very correct but takes up a lot of space.

• 8-bit (Quantization): This is like rounding it to 3.14. It's not perfectly correct, but it's "good enough" for most things and uses less space.

The challenge was how to round these numbers without breaking the model's math. This paper found a smart way to do it by treating "outliers" (a few very big numbers) specially, keeping them at high precision while rounding everything else.

Why Is It Important Today?

This technique (and newer ones like NF4 and GGUF) is the reason why developers and fans can run powerful open-source AI models (like Llama 3 70B) right on their laptops or gaming computers.

It made powerful AI models much more accessible to everyone, not just big tech companies.

What Are the Limits?

Quantization always has a small trade-off with speed or accuracy. While the LLM.int8 paper said it had no performance loss, "deeper" quantization (like 4-bit) definitely causes a small drop in accuracy. For most people, this trade-off is worth it to be able to run the model.

10. A Common Language For AI: "The MCP Announcement And Docs" (2024)

This is not a science paper, but an open industry standard announced by Anthropic (the company that makes Claude). It's called the "Model Context Protocol," or MCP.

The Document: Introducing The Model Context Protocol

What's the Big Idea?

Right now, if a developer wants an AI (like Claude) to connect to a tool (like Google Calendar, Slack, or Notion), they have to write custom "glue" code for every single tool.

MCP is an attempt to create a standard "common language," like how USB is a common standard for devices.

The idea is:

• Tool developers (like Notion) just need to make one "MCP server" for their product.

• AI developers (like Anthropic, OpenAI) just need to make their models "understand" MCP.

Then, any AI can automatically connect to and use any tool, with no custom code needed.

What Problem Did It Fix?

It fixes the "N x M" problem. If you have 100 AI models and 1000 tools, you have to build 100 * 1000 = 100,000 custom connections.

With MCP, you just build 100 models + 1000 tools = 1100 compatible parts. It makes the AI world much easier to connect.

How It Works (Simple Explanation):

Think about power outlets.

• Before MCP: Every country has a different kind of power outlet. If you bring your laptop from Vietnam (2-pin plug) to the UK (3-pin plug), you can't use it.

• With MCP: It's like everyone agrees to use one "universal travel adapter."

An MCP server tells the AI, "Hello AI, I am Notion. Here is what I can do: search_document(text) and create_new_page(title, content). Here is how you call them."

Any AI that understands MCP can read this message and automatically start using those tools.

Why Is It Important Today?

MCP is a very new idea (from late 2024), but it has huge potential. Google and OpenAI have also shown support for this standard.

If many companies adopt it, it could be the key to building truly powerful "Agents." An AI Agent could automatically "plug into" your calendar, email, databases, and other apps to finish complex tasks, just like a real human assistant.

What Are the Limits?

The main limit is that it is still too new. It needs the whole industry to accept it. Companies might not want to join if they feel it gives an advantage to a competitor. Security (what can the AI do with all these tools?) is also a big worry that needs to be solved.

Conclusion

AI technology seems to move very fast, but it is built on ideas that you can understand.

Hopefully, after reading this, you have a clearer picture of how we got here.

• We started with the Transformer (Attention), a better way for computers to understand language.

• We realized making them big (GPT-3) gave them the new skill of "few-shot learning."

• We taught them to be helpful and safe using human feedback (InstructGPT/RLHF).

• We gave them outside knowledge (RAG) and ways to take action in the real world (Agents).

• And at the same time, we found smart ways to make them cheaper, faster, and easier for everyone to use (LoRA, MoE, Quantization).

This is an exciting field, and by understanding these basics, you are in a great place to follow what happens next.

If you are interested in other topics and how AI is transforming different aspects of our lives or even in making money using AI with more detailed, step-by-step guidance, you can find our other articles here:

• The "Illegal" 10-Min Method To Master ANY New AI Model*

• Is The "Knowledge Work" Era Over? (40 Jobs AI Will & Won't Kill)

• AI Trading Battle: Grok 3 vs. DeepSeek vs. ChatGPT – Which One is More Profitable?*

• Forget Film School! THIS Is The Future Of AI Video Creation!*

• Make AI Your Co-Pilot: Mastering The Gemini Command Line

  *indicates a premium content, if any