Module 1: What Is AI Really?

5. AI in 2024-2026: Current state, what's possible and what isn't

Description

In this lesson you'll place artificial intelligence in the present: what's reasonable to expect today and in the coming years, what's exaggeration or myth, and what trends are setting the field's direction. These aren't infallible predictions; they're a framework for reading news, evaluating products and making decisions about your career or your use of AI.

The goal is for you to have a realistic view: neither "it's all smoke" nor "AGI in two years". Today's AI is very powerful in specific domains and keeps improving, but with clear limits. For an AI Engineer, knowing what's possible today (and what isn't) helps you design systems with the right expectations: RAG to reduce hallucinations, evaluation to detect failures, fallbacks when the model doesn't respond well.

Why the current state matters for your work

Before getting into "what's possible" and "what isn't", it's worth being clear about what this lesson is good for if you're going to work with AI:

Designing with the right expectations. If you assume the model "never hallucinates" or "remembers everything", you'll design products that fail in production. If you assume hallucinations are a structural limit and that context is finite, you'll design RAG, verification and fallbacks from the start.
Choosing your stack. The current state (APIs, RAG, agents, open source models, regulation) determines which tools you use: which provider, RAG or fine-tuning, agent or fixed flow, managed API or your own model.
Reading news and announcements with a critical eye. "Revolutionary", "changes everything", "AGI is around the corner" are claims you can contrast with what's actually possible today (and with the history of hype cycles you saw in lesson 03).
Communicating with product and business. Knowing what's possible (and what isn't) lets you explain why a product should include human review, why RAG reduces errors, or why "completely replacing X" isn't realistic today.

What's possible today (2024-2026)

Language (text)

Generating coherent text, summaries, translations, drafts, code from descriptions.
Answering questions about documents (RAG) or knowledge up to a certain date.
Conversing with limited context (a context window of several thousand or hundreds of thousands of tokens).
Classifying and extracting information from text (entities, sentiment, topics).

Known limits: Hallucinations (making up data or facts), inconsistency in long reasoning, sensitivity to the prompt, cost and latency in very large models. That's why critical applications use RAG (connecting the model to documents or databases) and human or automated evaluation. Hallucinations aren't "fixed" with a patch; they're mitigated through design (RAG, external verification, human oversight where applicable).

Why it matters for an AI Engineer: Your job is to choose the model, design prompts, connect to your own knowledge (RAG) and evaluate responses. Knowing that hallucinations are a structural limit (not a bug you fix with a patch) leads you to design pipelines that verify, cross-check or bound the responses. Don't assume "the model never makes up data"; design for the case where it does (cite sources, cross-check against a database, ask for human confirmation in critical uses).

Image and vision

Generating images from descriptions (DALL·E, Midjourney, Stable Diffusion, etc.).
Analyzing images: describing scenes, detecting objects, reading text (OCR).
Combining text and image (multimodal models that understand and generate both).

Known limits: Fine details (hands, text in images), coherence in very complex sequences or scenes, copyright and the ethical use of training data. Image models keep improving but aren't perfect; in production, human review is common for sensitive uses.

Voice and audio

Recognizing speech (transcription) with good accuracy in many languages.
Synthesizing very natural speech (text-to-speech).
Generating music or sound effects from descriptions (still in development).

Known limits: Very strong accents, background noise, minority languages, and the ethical use of cloned voices.

Code

Generating code from a description or from comments (Copilot, ChatGPT, Claude, etc.).
Explaining code, refactoring, detecting bugs or suggesting tests.
Completing lines or blocks in the editor (intelligent autocomplete).

Known limits: Very long or very specific code, libraries rarely seen in training, the need for human review for security and correctness.

Integration into products

APIs for models (OpenAI, Anthropic, Google, Meta, Mistral, etc.) to integrate language, vision or audio capabilities into applications.
RAG (Retrieval-Augmented Generation) to connect LLMs with your own knowledge bases.
Agents and tool use: models that call functions, search for information or execute steps (with supervision and limits).

Known limits: Cost, latency, privacy, dependence on providers, the need for careful design (prompts, evaluation, fallbacks). An AI Engineer has to choose between managed APIs (easier, less control) and their own or open source models (more control, more operations work).

What isn't possible (or isn't reliable) today

It's important to be clear about what you should not expect from current systems, so you don't design products that assume capabilities that don't exist or aren't reliable.

AGI (general intelligence): There's no system that learns and performs any human intellectual task.
Perfect mathematical or logical reasoning: Models make mistakes in proofs, long calculations or complex logic; you have to verify.
Unlimited memory and coherence: Context is limited by the model's window; they don't "remember" infinite conversations or real-time facts about the world without RAG or APIs.
Always-correct facts: Hallucinations are still present; they aren't reliable databases without verification.
Consciousness or "real" understanding: There's no evidence that current systems have consciousness; they're weak AI.
Complete replacement of experts in critical domains (medicine, law, security) without human oversight; they're used as support, not as a definitive replacement.

Analogy: It's like a very smart assistant who sometimes makes up facts and doesn't remember everything you told them a while ago. Useful if you design the system to verify, bound and complement; dangerous if you assume it's "always right" or "remembers everything".

Trends setting the direction (2024-2026)

More capable and cheaper models

Language and multimodal models keep improving in quality, speed and cost per token.
Open source models (Llama, Mistral, etc.) make it possible to run on your own infrastructure or to choose providers.
Competition among OpenAI, Anthropic, Google, Meta, Mistral and others keeps innovation and options coming.

Multimodality and agents

A single model that understands and generates text, image and sometimes audio.
Agents that plan, use tools (search, code, APIs) and execute steps; still with limits but evolving.

RAG and your own knowledge

Connecting LLMs to documents, databases or APIs to reduce hallucinations and update knowledge without retraining.
A central pattern for enterprise applications (support, documentation, internal analysis). An AI Engineer will have to design retrieval pipelines (embeddings, vector databases), choose which documents to include and evaluate the quality of responses (does it cite sources? does it answer with what's in the documents?).
RAG doesn't eliminate hallucinations 100%; it reduces them when the model is bounded to your own sources. It's still necessary to evaluate and, in critical uses, to verify or supervise.

Regulation and standards

Laws (e.g. the EU's AI Act) and codes of good practice (transparency, bias, data usage).
Impact on what can be deployed and how (documentation, evaluation, human oversight).

Cost and access

APIs and free or cheap tiers make experimentation possible; cost at scale is still a design variable.
Local options (LM Studio, Ollama) for privacy or low cost during development.

Small language models (SLMs)

Smaller models (1-7B parameters) optimized for specific tasks, with much lower cost and latency than large LLMs.
Useful when you don't need general capabilities (e.g. classification, extraction, answers in a bounded domain).
They make it possible to run on devices (phones, edge) without depending on cloud APIs.

Fine-tuning and specialized models

Adjusting pre-trained models with your own data to improve performance in a specific domain.
Increasingly accessible (fine-tuning APIs from OpenAI, Anthropic, Hugging Face).
It doesn't turn narrow into general; it improves within the narrow domain.

Why it matters for an AI Engineer: Your stack (API vs your own model, RAG vs fine-tuning, agents vs fixed flows) depends on these trends. Following the evolution of models, costs and regulation helps you make architecture and product decisions.

How to read news and announcements

When you read headlines or announcements about AI, use these criteria so you don't get misled:

"Revolutionary", "changes everything": Take it calmly; many times it's an incremental improvement, not a qualitative leap.
Demos and videos: They can be edited or cherry-picked; ask for evidence of performance under real conditions.
"AGI is around the corner": Today there's no consensus or evidence of AGI; these are projections or opinions, not fact.
Model comparisons: Check the date, the benchmark and the conditions; rankings change and benchmarks don't cover every use.
"It replaces profession X": In practice it's usually "assists" or "changes parts of the job"; total replacement is exceptional and usually requires supervision.

Common mistakes when interpreting the current state

1. "LLMs understand everything they say"

Mistake: Attributing understanding or consciousness to models.
Reality: They generate plausible sequences based on learned patterns; there's no consensus that they "understand" in the human sense. They can generate incorrect or incoherent things without "realizing it".

2. "With AI you no longer need to program"

Mistake: Believing that AI replaces software development.
Reality: AI is integrated into products through code (APIs, pipelines, evaluation, fallbacks). The programming role remains central; an AI Engineer is above all a software engineer who integrates models.

3. "ChatGPT is AGI"

Mistake: Treating today's LLMs as general intelligence.
Reality: They're narrow AI that's very capable at language; they don't generalize to any intellectual task, and no system considered AGI exists today.

4. "If the model fails once, it's useless"

Mistake: Expecting zero errors.
Reality: Models have error rates; it's the system's design (evaluation, verification, fallbacks, human oversight where applicable) that makes the product reliable, not the model being perfect.

Frequently asked questions

What is a hallucination?
When the model makes up data, facts or references that don't exist or aren't correct. It's a structural limit of LLMs (they learn patterns, they don't "know" facts); it's mitigated with RAG, external verification or human oversight.

Why does the model sometimes "forget" what I told it?
The context window is limited (even if it's hundreds of thousands of tokens); outside that window the model doesn't "see" the text. There's no native infinite memory; it's simulated with RAG, summaries or external databases.

Which model should I use for my product?
It depends on the use: cost, latency, languages, whether you need vision or only text, privacy (can you send data to an API?). There's no single answer; it's worth trying several and evaluating under real conditions.

Does regulation (e.g. the EU AI Act) affect me?
Yes, if you deploy products in the EU or in regulated sectors (health, education, etc.). It's worth reviewing requirements for transparency, risk assessment and human oversight according to the risk level of the use.

Quick comparison: what to expect by domain

To lock in the ideas, here's a table of what's reasonable to expect today (and what isn't) by domain. It isn't exhaustive; it's a framework for evaluating products and designs.

Domain	What's possible today	What isn't reliable (or doesn't exist)
Language (text)	Generating, summarizing, translating, classifying, RAG over documents	Zero hallucinations; infinite memory; perfect mathematical reasoning
Image	Generating from a description; describing; detecting objects; OCR	Perfect details (hands, text); infinite coherence across sequences
Voice	Transcription; very natural synthesis; many languages	Perfect performance with very strong accents or extreme noise; ethical cloning
Code	Generating, completing, explaining, refactoring, suggesting tests	Code that always compiles and does exactly what you ask without review
Integration	APIs, RAG, agents with tools	Zero cost; zero latency; total privacy with no trade-offs

Use this table when you evaluate a product or when you design one: if your design assumes something from the "what isn't reliable" column, revisit your expectations (verification, human oversight, fallbacks).

Quick reference: what to expect when designing

When you design an AI system, use this list so you don't assume capabilities that don't exist or aren't reliable today:

You can expect (and design for):

Generating and analyzing text, image and voice with good quality in bounded domains.
Integrating models via APIs (OpenAI, Anthropic, Google, Meta, Mistral, etc.).
Connecting LLMs with your own knowledge (RAG) to reduce hallucinations in a bounded domain.
Using agents that plan and call tools (with supervision and limits).
Evaluating responses (human or automated) and defining fallbacks for when the model fails.

You shouldn't assume (without explicit design):

Zero hallucinations; design RAG, verification or human oversight where applicable.
Infinite memory; context is finite; use RAG, summaries or external databases if you need to "remember" more.
Perfect mathematical or logical reasoning; verify critical results.
Total replacement of experts in critical domains without human oversight.
Zero cost or latency at scale; choose the model and provider according to product constraints.

Use this list when you set expectations with product or business, or when you evaluate whether a design is realistic today.

Examples by type of product (what to expect today)

To connect "what's possible" with concrete products, here are examples by type:

Type of product	What's reasonable to expect today	What you shouldn't assume
Chatbot / text assistant	Generating coherent responses, summarizing, translating, answering about documents (RAG)	Zero hallucinations; infinite memory; perfect mathematical reasoning
Recommendations (Netflix, Spotify, etc.)	Personalization based on history and preferences; improves with more data	That it never fails; that it "understands" your tastes in the philosophical sense
Image generation	Images from descriptions; good quality in many cases	Perfect details (hands, text); infinite coherence across sequences
Voice transcription	Good accuracy in many languages and accents	Perfect performance in extreme noise or with very strong accents
Code assistant (Copilot, etc.)	Completing lines, generating code from a description, explaining code	That it always compiles and does exactly what you ask without review
RAG (questions over documents)	Answers bounded to your own sources; fewer hallucinations than without RAG	Zero hallucinations; that it never miscites or makes up sources

Use this table when you evaluate a product or when you set expectations for one you're designing.

One-page summary

What's possible today: Generating and analyzing text, image and voice; integrating models via APIs; RAG and agents with known limits.
What isn't possible (or isn't reliable): AGI; perfect reasoning; unlimited memory; zero hallucinations; total replacement of experts without oversight.
Structural limits: Hallucinations (mitigate with RAG, verification); finite context (use RAG, summaries); cost and latency (choose the model and provider).
Trends: More capable and cheaper models; multimodality; agents; RAG; regulation (EU AI Act).
Read with a critical eye: "Revolutionary", "AGI is around the corner", "it replaces profession X" → contrast with evidence and real conditions.
For an AI Engineer: Design with the right expectations (RAG, evaluation, fallbacks); choose your stack (API vs your own model, RAG vs fine-tuning); communicate limits to product and business.
Common mistakes: "LLMs understand everything" (false); "With AI you no longer need to program" (false); "ChatGPT is AGI" (false); "If the model fails once, it's useless" (false).
Resources: State of AI Report, AI Index (Stanford), McKinsey (state of AI), EU AI Act, Anthropic/OpenAI (model cards).
Design implications: When you design a system (RAG, agent, API), use the "What's possible today" and "What isn't possible" tables so you don't assume capabilities that don't exist or aren't reliable. Design RAG, verification and fallbacks from the start.

Summary of implications for AI Engineering

The current state of AI has direct consequences for how you work as an AI Engineer:

Design with the right expectations. If you assume the model "never hallucinates" or "remembers everything", you'll design products that fail in production. If you assume hallucinations are a structural limit and that context is finite, you'll design RAG, verification and fallbacks from the start.
Choose your stack based on what's possible today. The current state (APIs, RAG, agents, open source models, regulation) determines which tools you use: which provider, RAG or fine-tuning, agent or fixed flow, managed API or your own model.
Communicate limits to product and business. Use this lesson's "What's possible today" and "What isn't possible" tables. If the product assumes zero hallucinations or infinite memory, explain that these are structural limits and that they're mitigated with RAG, verification and fallbacks.
Read news and announcements with a critical eye. "Revolutionary", "changes everything", "AGI is around the corner" are claims you can contrast with what's actually possible today and with the history (lesson 03: hype cycles).
Use the "Examples by type of product" table when you evaluate. When you evaluate a product or set expectations for one you're designing, use this lesson's "Examples by type of product" table so you don't assume capabilities that don't exist or aren't reliable.
Use the "Quick comparison: what to expect by domain" table when you set expectations. The table (language, image, voice, code, integration) helps you not assume "what isn't reliable" (zero hallucinations, infinite memory, etc.) when you design or evaluate a product.

Use this summary when you set expectations, when you choose your stack or when you communicate limits to product and business.

Notes for going deeper

Why aren't hallucinations "fixed" with a patch? Because they're a structural limit of how LLMs work (they learn patterns, they don't "know" facts). They're mitigated through design: RAG (connecting to your own sources), external verification, human oversight where applicable. Don't assume "the model never makes up data"; design for the case where it does.

What to do when you set expectations with product or business? Use this lesson's "What's possible today" and "What isn't possible" tables. If the product assumes zero hallucinations or infinite memory, revisit expectations (RAG, verification, fallbacks). If the product assumes "total replacement of profession X", add nuance: in practice it's usually "assists" or "changes parts of the job".

How to use this lesson in the bootcamp or in another guide? When you design a system (RAG, agent, API), remember what's possible today (and what isn't). That determines your stack (which model, RAG or fine-tuning, human verification or not) and your communication with product and business (limits, evaluation, oversight).

What questions to ask when you hear "revolutionary" or "changes everything"? On what benchmark? Under what conditions? Compared with what? Contrast it with evidence (benchmarks, real usage conditions) and with the history (lesson 03: hype cycles).

Questions to reflect on

Why aren't hallucinations "fixed" with a patch? Because they're a structural limit of LLMs (they learn patterns, they don't "know" facts). They're mitigated through design: RAG (connecting to your own sources), external verification, human oversight where applicable.

Why does the model "forget" what I told it? Because the context window is limited (even if it's hundreds of thousands of tokens); outside that window the model doesn't "see" the text. There's no native infinite memory; it's simulated with RAG, summaries or external databases.

Why shouldn't you assume "total replacement of profession X"? Because in practice it's usually "assists" or "changes parts of the job"; total replacement is exceptional and usually requires human oversight. In critical domains (medicine, law, security) they're used as support, not as a definitive replacement.

Which trend affects you most as an AI Engineer? It depends on your context: RAG (designing retrieval pipelines, embeddings, vector databases); agents (designing flows and tools); regulation (documentation, risk assessment); multimodality (products that combine text and image).

How do you communicate limits to product or business? Use this lesson's "What's possible today" and "What isn't possible" tables. If the product assumes zero hallucinations or infinite memory, explain that these are structural limits and that they're mitigated with RAG, verification and fallbacks.

Executive summary (for quick review)

Possible today: Generating/analyzing text, image, voice; APIs; RAG; agents with limits.
Not possible (or not reliable): AGI; perfect reasoning; infinite memory; zero hallucinations; total replacement without oversight.
Limits: Hallucinations (RAG, verification); finite context (RAG, summaries); cost/latency (choose the model).
Trends: More capable and cheaper models; multimodality; agents; RAG; regulation.
Read with a critical eye: "Revolutionary", "AGI now", "it replaces X" → contrast with evidence.
For an AI Engineer: Right expectations (RAG, evaluation, fallbacks); choose your stack; communicate limits.
Mistakes: "LLMs understand everything" (false); "With AI you don't need to program" (false); "ChatGPT is AGI" (false); "If it fails once, it's useless" (false).
Resources: State of AI Report, AI Index, McKinsey, EU AI Act, Anthropic/OpenAI (model cards).

Connection with the rest of the guide

Module 6 (APIs): The current state is what makes "integrating an LLM via API" the daily bread of an AI Engineer.
Module 7 (AI Engineering): Your role exists because there are powerful models but with limits; your job is to design systems that use them well (RAG, prompts, evaluation, fallbacks).
Module 8 (Design): Designing an AI system today means choosing feasible tasks (narrow AI), models and APIs, and explicitly assuming limits (hallucinations, context, cost).

Exercises

Exercise 1: Possible today or not?

Say whether it's reasonable to expect it today (2024-2026) with existing systems (yes/no) and why, in one sentence:

Translating a long document between two languages with good quality.
A model that never makes up an incorrect fact.
A chatbot that remembers an entire conversation from a year ago with no context limit.
Generating code that always compiles and does exactly what you ask without review.

See solution

Yes. Machine translation with LLMs or dedicated systems is possible and used in production; quality is good for many language pairs.
No. LLMs can hallucinate; there's no guarantee of zero factual errors without external verification (RAG, databases, humans).
No. The context window is limited (even if it's large); there's no native infinite "memory"; it's simulated with RAG or summaries, not with a full year of context.
No. Code generation requires human review; there's no guarantee of correctness or that it always compiles without iterating.

Exercise 2: Myths in one sentence

Write a sentence that corrects each myth:

A) "LLMs understand everything they say."
B) "With AI you no longer need to program."
C) "ChatGPT is AGI."

See answer guide

Guide:
A) LLMs generate plausible sequences based on learned patterns; there's no consensus that they "understand" in the human sense; they can generate incorrect or incoherent things.
B) AI is integrated into products through code (APIs, pipelines, evaluation); the programming role remains central, especially in AI Engineering.
C) ChatGPT is narrow AI that's very capable at language; it isn't AGI: it doesn't generalize to any intellectual task, and no system considered AGI exists today.

Exercise 3: A trend that affects you

Choose a trend (cheaper models, RAG, agents, regulation, multimodality) and explain in 2–3 sentences how it can affect an AI Engineer's work in the coming years.

See answer guide

Guide (example with RAG): "RAG has become a standard pattern for connecting LLMs with your own knowledge; an AI Engineer will have to design retrieval pipelines, choose embeddings and vector databases, and evaluate the quality of responses. Anyone who doesn't know how to design and maintain RAG will have less of an edge in enterprise applications."

You can do the same with other trends (agents → designing flows and tools; regulation → documentation and evaluation; multimodality → products that combine text and image).

Exercise 4: Limit and mitigation

For each limit, write one reasonable way to mitigate it in a real product (one sentence per limit):

Hallucinations (making up facts).
Limited context window (the model "forgets").
High cost at scale.

See answer guide

Guide (examples):

Connect the model to documents or databases (RAG) so it cites sources; external verification or human oversight in critical uses.
Summarize long conversations; use RAG to retrieve relevant information; store context in a database and inject it when needed.
Choose smaller or cheaper models when the task doesn't require the most capable one; cache responses; use free tiers or open source models for development.

Exercise 5: Myth or reality?

Say whether it's a myth or reality (and why, in one sentence):

A) "An LLM can remember an entire year-long conversation."
B) "An LLM can generate code that always compiles without review."
C) "RAG reduces hallucinations by connecting the model to your own sources."

See solution

A) Myth. The context window is limited; there's no native infinite memory; it's simulated with RAG or summaries, not with a full year of context.
B) Myth. Code generation requires human review; there's no guarantee of correctness or that it always compiles without iterating.
C) Reality. RAG connects the model to documents or databases; that bounds the responses to specific sources and reduces (doesn't eliminate) the invention of facts.

Exercise 6: Critical headline

A headline says: "New model surpasses humans at mathematical reasoning." Write 2–3 questions you would ask to evaluate whether the claim is solid (benchmark, conditions, type of problems).

See answer guide

Guide (examples): On what benchmark? What type of problems (basic arithmetic vs long proofs)? Under what conditions (without tools, with a calculator)? Compared with what level of human (student, expert)? Does the model make mistakes in some percentage of cases? Are the results reproducible?

Summary

In one sentence - Current state (2024-2026): Narrow AI that's very capable in specific domains (language, image, voice), with clear limits (hallucinations, context, cost) and continuous improvement; AGI doesn't exist.

Key points:

Possible today: Generating and analyzing text, image and voice; integrating models via APIs; using RAG and agents with known limits.
Not possible today (or not reliable): AGI, perfect reasoning, unlimited memory, zero hallucinations, total replacement of experts without oversight.
Relevant trends: More capable and cheaper models, multimodality, agents, RAG, regulation and standards.
Read with a critical eye: Be skeptical of "total revolution" and "AGI now"; contrast demos with evidence and real usage conditions.
For an AI Engineer: The current state means integrating powerful narrow AI, assuming limits and designing systems (RAG, evaluation, fallbacks) that work in production.

Additional resources

The State of AI Report (annual) — An annual summary of the state of the field: models, investment, regulation and trends; useful for having an up-to-date view (in English). Complements the "Trends" section of this lesson.
AI Index (Stanford HAI) — Data and trends on research, investment and adoption; complements the previous report with metrics (in English). Useful for contrasting claims with data.
McKinsey: The state of AI (2024) — AI use in companies, expectations and use cases; a business perspective (in English). Connects "what's possible today" with adoption in companies.
EU AI Act — The regulatory framework in the EU; risk levels, obligations and deadlines; relevant if you deploy in Europe (in English).
Anthropic: Claude Model Card — Documentation of Claude's capabilities and limits; an example of how a provider communicates what a model can and can't do (in English).
OpenAI: GPT-4 System Card — A summary of GPT-4's capabilities, limits and risks; useful for connecting the "current state" with a specific model (in English).

← Previous4. Types of AI: Narrow vs General, Weak vs Strong Next →6. Exercise: AI all around you