When AI Meets Mathematics: How Machines Could Change the Way We Discover and Understand Math

Mathematics has traditionally been a human-driven discipline. From ancient geometry to modern number theory, mathematicians have developed new ideas through observation, logical reasoning, experimentation, and proof. Today, artificial intelligence is introducing a new tool into this process.

AI is not simply being used to calculate numbers faster. Researchers are exploring how machine-learning systems can discover patterns, suggest mathematical relationships, generate conjectures, and even assist with difficult proofs. This could eventually change not only how mathematics is done, but also how humans understand mathematical ideas.

AI Is Becoming a Mathematical Research Partner

Computers have been helping mathematicians for decades, but modern AI systems can work differently from traditional mathematical software.

A conventional program usually follows instructions created by humans. AI models, particularly systems designed for mathematical reasoning, can examine large amounts of mathematical information and identify relationships that might be difficult to notice manually.

For example, an AI system could analyze thousands of mathematical structures and detect a possible connection between two areas of mathematics. A mathematician could then investigate whether that observation represents a genuine theorem.

This creates a new research cycle:

AI finds a pattern → mathematician studies it → a conjecture is proposed → humans or computers attempt a proof.

From Calculations to Mathematical Discovery

One of the most interesting possibilities is that AI could help discover new mathematical ideas rather than simply solve existing problems.

Suppose researchers give an AI system a collection of mathematical objects. The system may notice that certain properties repeatedly occur together. It could then suggest a hypothesis such as:

"Whenever these conditions are satisfied, this particular relationship may also be true."

Such a statement would only be a conjecture until it is mathematically proven. However, finding useful conjectures is an important part of mathematical research.

AI could therefore become a tool for exploring the enormous space of possible mathematical relationships.

AI Could Help Reveal Hidden Connections

Mathematics contains many areas that appear unrelated at first.

Number theory, geometry, algebra, probability and topology, for example, use different concepts and techniques. Yet researchers often discover surprising connections between them.

AI could potentially help identify these relationships by analyzing mathematical structures across different fields.

A system might recognize that a pattern appearing in one mathematical area resembles a structure found somewhere else. This could give researchers a new direction for investigation.

The important point is that AI would not necessarily "understand" the connection in the same way a mathematician does. Instead, it could act as a powerful pattern-finding assistant.

The Growing Role of Automated Proof

Proof is at the heart of mathematics.

A mathematical statement is not accepted as a theorem merely because it works in thousands or millions of examples. It requires a logical proof showing why the statement must be true.

AI-assisted theorem proving is therefore an important area of research.

Modern systems can help search for logical steps, select useful mathematical techniques and work with formal proof systems. In some cases, this can reduce the amount of routine work required from mathematicians.

Formal verification also provides an important advantage: once a proof has been translated into a suitable formal system, software can check whether the logical steps follow correctly.

Will AI Replace Mathematicians?

Probably not in the simple sense of replacing human mathematicians completely.

Mathematics involves much more than producing an answer. Researchers need to decide:

• Which questions are worth investigating?
• Why is a particular problem important?
• Which concepts should be developed?
• What does a new theorem actually mean?
• How does one result connect with existing knowledge?

These questions involve creativity, judgment and interpretation.

AI may instead become another powerful instrument in the mathematician's toolbox, similar to how calculators, computers and mathematical software changed research without eliminating the need for mathematicians.

A New Way to Learn Mathematics

AI could also change mathematics education.

Instead of receiving the same explanation from a textbook, students could potentially ask an AI system to explain a concept at different levels.

For example, a student learning algebra might ask:

"Explain this equation like I am a beginner."

Then they could ask:

"Show me a visual explanation."

And finally:

"Give me a harder problem based on the same idea."

This could make mathematics more interactive and personalized.

However, there is a potential problem. If students allow AI to solve every problem for them, they may miss the opportunity to develop their own mathematical reasoning.

The goal should therefore be to use AI as a learning assistant, rather than simply an answer generator.

AI May Change What We Consider an Explanation

There is another deeper question: Is finding a correct answer enough?

Mathematicians often care about elegant proofs and explanations. Two proofs may establish exactly the same result, but one may reveal a much deeper idea.

AI might discover a complicated proof that works but is difficult for humans to understand. This raises an interesting possibility: AI could prove mathematical statements that humans struggle to explain intuitively.

That could lead to a new challenge for mathematics:

How do we transform machine-generated discoveries into human understanding?

Future mathematicians may spend more time interpreting AI-generated results and finding simpler explanations for them.

The Risk of Incorrect Mathematical Reasoning

AI systems are not automatically reliable mathematicians.

A model can produce an answer that looks convincing while containing a subtle error. This is particularly dangerous in mathematics because a small logical mistake can invalidate an entire argument.

For this reason, AI-generated mathematical claims need verification.

Tools such as symbolic mathematics systems, formal proof assistants and independent calculations can help check proposed solutions.

Human oversight will remain important, particularly for new research.

Could AI Discover Completely New Mathematics?

This is one of the most fascinating possibilities.

AI systems could potentially explore mathematical spaces far larger than humans can examine manually. They might identify structures, patterns or conjectures that would otherwise remain unnoticed.

But discovering something new is only the beginning.

Mathematicians would still need to determine what the discovery means, prove it, connect it to existing mathematics and decide whether it represents a genuinely important idea.

If this collaboration becomes successful, mathematics could develop a new research model in which humans provide intuition and direction while AI provides enormous computational exploration.

The Future of Mathematics

AI may influence mathematics at several levels:

Calculation: Performing complicated computations faster.

Pattern discovery: Finding relationships in large mathematical datasets.

Conjecture generation: Suggesting statements that might be true.

Proof assistance: Helping researchers construct or verify proofs.

Education: Providing personalized explanations and practice.

Research: Exploring mathematical structures that are difficult for humans to investigate manually.

The most significant change may not be that AI solves mathematics faster. It may be that AI helps humans ask different questions.

Final Thoughts

Artificial intelligence is opening a new chapter in the relationship between computers and mathematics. Machines can already assist with calculations, symbolic manipulation, pattern recognition and aspects of mathematical proof. As these systems become more capable, their role could expand from solving problems to helping researchers discover new mathematical ideas.

The biggest opportunity may lie in collaboration. Humans bring curiosity, intuition, interpretation and the ability to decide which questions matter. AI brings speed, scale and the ability to search through enormous numbers of possibilities.

The future of mathematics may therefore not be humans versus machines, but humans working with machines to explore mathematics in ways neither could easily accomplish alone.

 

Build a Website with AI and Publish It Online: Free and Paid Options

Artificial intelligence has changed the way websites are designed, developed, and published. You no longer need to spend weeks learning every part of web development before creating a website. With the right AI tools, beginners can generate website ideas, write code, create content, design layouts, and even prepare a website for online deployment.

Whether you want to build a personal portfolio, blog, business website, online store, or web application, AI can significantly reduce the time required to get started.

What Does “Build a Website with AI” Mean?

Building a website with AI means using artificial intelligence to assist with different stages of website development.

AI can help you:

• Generate HTML, CSS, and JavaScript
• Create responsive page layouts
• Write website content
• Suggest color combinations and fonts
• Build navigation menus
• Generate forms and interactive components
• Find and fix coding errors
• Explain programming concepts
• Create SEO-friendly page structures
• Convert an idea into a working website

For example, you could tell an AI assistant:

“Create a responsive website for a technology blog with a homepage, article cards, search box, categories, and dark mode.”

The AI can then produce the initial structure and code that you can modify.

Step 1: Decide What Website You Want

Before asking AI to generate anything, define the purpose of your website.

You could create:

• A personal portfolio
• A technology blog
• A business website
• An educational website
• An online tool
• A news website
• A landing page
• An online community
• A web application

A clear idea makes it easier for AI to generate useful results.

For example:

Website idea: AI and technology blog

Pages:

• Home
• About
• Categories
• Articles
• Contact
• Privacy Policy

You can then give these requirements to an AI coding assistant.

Step 2: Ask AI to Generate the Website

You don't have to ask AI to create the entire project in one huge request.

A better approach is to build it step by step.

Start with:

“Create a responsive homepage for my AI technology blog using HTML and CSS.”

Then continue with:

“Add a navigation bar and mobile-friendly menu.”

Then:

“Add article cards with image, title, category and date.”

Finally:

“Add a dark mode button using JavaScript.”

This approach makes the project easier to understand and troubleshoot.

Step 3: Choose Your Technology

A simple website can be created using:

HTML — page structure

CSS — design and layout

JavaScript — interaction and functionality

For larger applications, you can explore technologies such as React, Next.js, Node.js, Python, or databases.

If you are a beginner, starting with HTML, CSS, and JavaScript is often easier than immediately jumping into a complicated framework.

Step 4: Test Your Website

Never publish AI-generated code without testing it.

Check:

• Does the navigation work?
• Do buttons work?
• Does it look good on a phone?
• Are images loading?
• Are forms working?
• Are links correct?
• Is the website fast?
• Is the text readable?
• Are there console errors?

AI can generate useful code, but it can also make mistakes. Testing remains an important part of development.

Free Ways to Put Your Website Online

You don't necessarily need to buy hosting immediately.

For a static website, several services offer free hosting options.

You can use platforms such as:

• GitHub Pages
• Cloudflare Pages
• Netlify
• Vercel

These platforms can host websites containing HTML, CSS, JavaScript and, depending on the platform, applications using supported frameworks.

A typical process looks like this:

Create website → Put code in a repository → Connect hosting platform → Deploy → Get a public URL

Your website can then be accessed by people through the internet.

What About a Free Domain?

Free hosting doesn't always mean you receive a free custom domain.

Many free hosting services provide a platform-generated address, while a custom domain such as:

mywebsite.com

usually requires purchasing a domain.

For learning, experimenting, or launching a small project, the free platform address can be perfectly adequate.

Paid Website Options

Once your website begins attracting visitors, you may want more control.

A paid setup can include:

• Custom domain
• Premium hosting
• Larger storage
• Higher traffic limits
• Database services
• Business email
• Advanced security
• Analytics
• Backup systems
• Additional server resources

A basic paid website does not necessarily need to be expensive. Your actual cost depends on the type of website, traffic, domain, hosting provider, and additional services you use.

Free vs Paid Website

Feature	Free Setup	Paid Setup
Website hosting	Often available	Available
Custom domain	Usually limited/not included	Usually available
Basic website	Yes	Yes
SSL/HTTPS	Commonly available	Commonly available
Large traffic	May have limits	More resources available
Database	Depends on service	More options
Business email	Usually limited/not included	Available with suitable service
Support	Usually limited	Often better
Advanced features	May have restrictions	More flexibility

The right choice depends on your project rather than simply choosing the most expensive option.

Can AI Build a Complete Website?

AI can help create a surprisingly large portion of a website, but it should be treated as a development assistant rather than a replacement for testing and decision-making.

AI can generate:

Design → Code → Content → Components → Documentation → Debugging help

However, you still need to check the result for security, accuracy, accessibility, performance, copyright issues, and usability.

For an important business website, human review is especially important.

Turn Your Website into a Business

Once you understand how to create and publish websites, you can go beyond personal projects.

For example, you could create:

• AI-powered tools
• Subscription websites
• Online courses
• SaaS applications
• Developer tools
• Job portals
• Blogging platforms
• Educational applications
• Business websites

Some websites can remain completely free, while others can use a freemium model.

What Is Freemium?

Freemium means providing basic features for free while charging for additional features.

For example:

Free plan

• 5 projects
• Basic templates
• Limited AI usage

Paid plan

• Unlimited projects
• Premium templates
• More AI requests
• Advanced analytics
• Priority support

This model can be useful when you are building an AI-powered online service.

A Simple AI Website Development Workflow

You can follow this workflow:

1. Idea

Decide what problem your website solves.

↓

2. Planning

Ask AI to help create the site structure and feature list.

↓

3. Design

Create the layout and user interface.

↓

4. Development

Use AI to generate and explain the code.

↓

5. Testing

Test the website on computers and smartphones.

↓

6. Deployment

Publish it using a hosting platform.

↓

7. Domain

Connect a custom domain if required.

↓

8. Improvement

Use visitor feedback and analytics to improve the website.

Final Thoughts

Building a website is becoming much more accessible because AI can assist with coding, design, content creation, debugging, and planning. Beginners can start with a simple HTML, CSS, and JavaScript project and gradually move toward more advanced applications.

You can experiment with free hosting before spending money. Once your website gains users or requires additional features, you can move to a paid hosting plan, custom domain, database, or other services.

The most important thing is not simply asking AI to “build a website.” Instead, use AI as a development partner: explain your idea, build the project step by step, understand the generated code, test everything, and keep improving the result.

With this approach, an idea can go from concept → AI-assisted development → free online website → professional paid service without requiring a large initial investment.

 

Python List Comprehension Made Easy: Square Only the Even Numbers

List comprehension is one of Python’s most useful features for creating a new list from an existing collection. It allows developers to combine filtering and transformation into a compact, readable expression.

A common interview-style problem is to take a list of numbers, identify the even values, and then calculate their squares.

Let’s understand how to solve it step by step.

The Problem

Suppose we have the following list:

numbers = [1, 5, 2, 8, 3, 7]

The goal is to:

1. Find the even numbers.
2. Calculate the square of each even number.
3. Store the results in a new list.

The expected result is:

[4, 64]

Why?

• 2 is even → 2² = 4
• 8 is even → 8² = 64

The other numbers are odd, so they are ignored.

The Python Solution

numbers = [1, 5, 2, 8, 3, 7]

squares_even = [x**2 for x in numbers if x % 2 == 0]

print(squares_even)

Output:

[4, 64]

Understanding the List Comprehension

The most important part of the program is:

[x**2 for x in numbers if x % 2 == 0]

It may look complicated at first, but we can break it into three simple parts.

1. for x in numbers

for x in numbers

This goes through every number in the list one by one.

The values are:

1
5
2
8
3
7

2. if x % 2 == 0

This checks whether the number is even.

The % operator gives the remainder after division.

For example:

2 % 2 = 0
8 % 2 = 0

Therefore, 2 and 8 are even.

But:

1 % 2 = 1
5 % 2 = 1
3 % 2 = 1
7 % 2 = 1

These numbers are odd and are skipped.

3. x**2

The ** operator is used for exponentiation in Python.

So:

x**2

means:

x × x

For the selected numbers:

2**2 = 4
8**2 = 64

Therefore, the final list becomes:

[4, 64]

The Same Logic Without List Comprehension

Understanding the longer version can make the one-line solution easier to remember.

numbers = [1, 5, 2, 8, 3, 7]

squares_even = []

for x in numbers:
    if x % 2 == 0:
        squares_even.append(x**2)

print(squares_even)

This produces the same output:

[4, 64]

The list comprehension simply puts this logic into a more compact form.

A Simple Formula to Remember

A useful pattern for this type of problem is:

[new_value for item in list if condition]

For this example:

[x**2 for x in numbers if x % 2 == 0]

You can think of it as:

Take → Check → Transform

• Take: each number from numbers
• Check: is it even?
• Transform: square it

Why List Comprehension Is Useful

List comprehensions are particularly useful when working with lists of data. They can make straightforward filtering and transformation operations shorter and easier to read.

For example, you can use them to:

• Filter values from a dataset
• Transform numbers
• Extract specific values
• Clean simple collections
• Prepare data for further processing

However, shorter code is not automatically better. If a list comprehension becomes complicated, a normal for loop may be easier for other developers to understand.

Another Example

Suppose we have:

numbers = [2, 4, 5, 7, 10]

We want the squares of even numbers:

result = [x**2 for x in numbers if x % 2 == 0]

print(result)

Output:

[4, 16, 100]

Here, 2, 4, and 10 are even, so only those numbers are squared.

Interview Tip

If an interviewer asks you to use list comprehension for a filtering-and-transformation problem, first identify these three things:

1. What should be selected?

Example:

if x % 2 == 0

2. What transformation should be performed?

Example:

x**2

3. What is the original list?

Example:

numbers

Then combine them:

[x**2 for x in numbers if x % 2 == 0]

Conclusion

Python list comprehension provides a concise way to filter and transform data. In this example, the expression checks every number, keeps only the even values, squares them, and creates a new list.

The complete solution is:

numbers = [1, 5, 2, 8, 3, 7]

squares_even = [x**2 for x in numbers if x % 2 == 0]

print(squares_even)

Output:

[4, 64]

This simple example is also a good introduction to a broader Python programming pattern: filter data based on a condition and transform the values that pass the filter.

 

Top 5 Open-Source Video Generation Models in 2026

AI video generation has moved rapidly from experimental research into practical creative and development workflows. Open-source and open-weight models are particularly interesting because developers can inspect model implementations, download available weights, run models locally, and build customized applications around them. However, “open source” can mean different things across projects, so users should always check the specific model's licence and usage conditions.

Below are five notable open video-generation model families to explore in 2026.

1. Wan 2.1

Wan 2.1, developed by Alibaba's Wan team, is a versatile video-generation family supporting several generation and editing tasks. Its capabilities include text-to-video, image-to-video, video editing, text-to-image and video-to-audio workflows.

One of its notable features is the availability of a 1.3B-parameter model, which has substantially lower hardware requirements than the larger 14B version. The project's documentation states that the T2V-1.3B model can operate with around 8.19 GB of VRAM under its specified setup.

Key features

• Text-to-video generation
• Image-to-video generation
• Video editing capabilities
• Multiple model sizes
• Community support for tools such as ComfyUI
• Apache 2.0 licensing for the Wan 2.1 models, according to its repository

Best suited for: Developers and creators looking for a flexible model family with options for different hardware levels.

2. HunyuanVideo

HunyuanVideo is Tencent's open video-generation project and is built around a large-scale video foundation model. The original model contains more than 13 billion parameters and uses a combination of video-focused architecture, a 3D VAE and language-based conditioning.

The project provides inference code, model checkpoints and integrations with technologies such as Diffusers and ComfyUI. It also has an image-to-video model within the broader HunyuanVideo ecosystem.

The major consideration is hardware. Tencent's documentation lists peak GPU memory requirements of approximately 45 GB for a 544×960 configuration and 60 GB for a 720×1280 configuration for the original model.

Key features

• High-quality text-to-video generation
• Image-to-video development
• Large-scale video foundation architecture
• Multi-GPU inference support
• Diffusers and ComfyUI ecosystem

Best suited for: Researchers and developers with powerful GPUs who want to experiment with a large video-generation architecture.

3. CogVideoX

CogVideoX is an open video-generation model family associated with THUDM and the wider Hugging Face ecosystem. It has become popular among developers because it can be integrated into Python-based workflows and Diffusers-based projects.

The model family includes different parameter sizes, making it possible to experiment with configurations suited to different computational environments.

CogVideoX is particularly interesting for programmers who want to integrate video generation into their own applications rather than relying exclusively on a graphical interface.

Key features

• Text-to-video generation
• Image-to-video capabilities
• Python-based workflows
• Hugging Face Diffusers integration
• Open model ecosystem

Best suited for: Python developers, AI researchers and people experimenting with custom video-generation applications.

4. LTX-Video

LTX-Video, developed by Lightricks, focuses strongly on efficient video generation. The model is based on a diffusion-transformer architecture and has been designed to make video generation comparatively fast on capable hardware.

The LTX ecosystem has also continued to evolve, with newer LTX model generations adding capabilities beyond the original LTX-Video project. Current open-weight comparisons include the newer LTX family alongside models such as Wan and HunyuanVideo.

Key features

• Text-to-video generation
• Image-to-video workflows
• Fast generation on suitable hardware
• ComfyUI support
• Developer-oriented workflows

Best suited for: Creators and developers who place a high priority on generation speed and iterative experimentation.

5. Mochi 1

Mochi 1, created by Genmo, is another important open video-generation model. It uses an Asymmetric Diffusion Transformer architecture and has been released as an open model under the Apache 2.0 licence, according to curated open-model references.

Mochi 1 is designed primarily for text-to-video generation and has become part of the wider ecosystem of models that researchers can download, experiment with and integrate into different video-generation pipelines.

Key features

• Text-to-video generation
• Diffusion Transformer architecture
• Open model weights
• Apache 2.0 licensing
• Integration with community AI-video workflows

Best suited for: AI enthusiasts and researchers interested in experimenting with open video-generation architectures.

Comparison at a Glance

Model	Main Strength	Generation Focus	Hardware Consideration
Wan 2.1	Versatility	T2V, I2V, editing	Multiple model sizes
HunyuanVideo	Large-scale generation	T2V, I2V	Very demanding for original model
CogVideoX	Developer ecosystem	T2V, I2V	Depends on model variant
LTX-Video	Speed and workflow flexibility	T2V, I2V	Designed for efficient generation
Mochi 1	Open research	T2V	Requires capable hardware

T2V = text-to-video; I2V = image-to-video.

Why Open-Source Video Models Matter

Open video models are changing how developers approach generative media. Instead of sending every prompt to a proprietary cloud service, developers can potentially run compatible models locally or deploy them on their own infrastructure.

This provides several advantages:

1. More experimentation

Researchers can investigate model architecture, inference techniques and different generation workflows.

2. Greater customization

Developers can connect models to applications, automation systems and creative pipelines.

3. Local generation

Where hardware and licences permit, users can generate content locally rather than relying entirely on an external service.

4. Growing community ecosystems

Projects such as ComfyUI, Diffusers and other open-source tools make it easier to experiment with multiple video models in a common workflow.

What Should You Consider Before Choosing a Model?

There isn't one model that is suitable for every project. Consider:

Hardware: Large video models can require substantial GPU memory. HunyuanVideo's original configuration, for example, can require tens of gigabytes of VRAM.

Generation type: Decide whether you need text-to-video, image-to-video, video editing or another workflow.

Speed: If you need to test many prompts, an efficient model may be more practical than a much larger model.

Licence: Carefully read the licence for the exact checkpoint you intend to use, particularly for commercial projects. Open weights do not automatically mean unrestricted commercial usage.

Software compatibility: Check whether your preferred workflow supports the model through tools such as Diffusers or ComfyUI.

Conclusion

Open-source and open-weight video generation is becoming one of the most active areas of generative AI. Wan 2.1, HunyuanVideo, CogVideoX, LTX-Video and Mochi 1 represent five important model families for developers and researchers exploring AI-generated video.

The biggest difference between them is not simply visual quality. Hardware requirements, generation modes, speed, software support, customization options and licensing can all affect which model fits a particular project. As new releases continue to appear, checking the official repository and licence for the specific model version is essential.

 

AI and the Navier–Stokes Mystery: Has OpenAI Finally Solved a 90-Year-Old Problem?

For nearly a century, mathematicians have struggled with one of the most difficult questions in fluid dynamics: the Navier–Stokes existence and smoothness problem. In September 2026, OpenAI announced that an internal AI system had produced a mathematical solution, potentially marking a major moment in the history of artificial intelligence and mathematics.

But there is an important distinction: OpenAI has presented a solution, while independent mathematical evaluation and formal recognition are separate matters. The Clay Mathematics Institute has reportedly described the problem as apparently settled while emphasizing that evaluation and credit take time.

What Are the Navier–Stokes Equations?

The Navier–Stokes equations are fundamental mathematical tools used to describe how fluids move. They can be applied to phenomena ranging from airflow around aircraft to water currents and atmospheric motion.

At a simplified level, the equations account for factors such as:

• Fluid velocity
• Pressure
• Viscosity
• Momentum
• External forces

The equations themselves are well known. The difficult question is whether their three-dimensional solutions can remain smooth forever or whether they can develop a mathematical singularity in finite time.

That question has remained unresolved for roughly 90 years.

Why Is the Problem So Difficult?

Fluids can behave in extremely complicated ways.

A small disturbance can produce swirling structures, interacting vortices and turbulent motion. Mathematically describing all of these effects becomes particularly challenging in three dimensions.

The Millennium Prize version of the problem asks mathematicians to establish whether smooth solutions remain well behaved for all time, or whether a singularity can occur.

The problem is one of the seven Millennium Prize Problems, each originally associated with a $1 million prize.

What Did OpenAI's AI System Find?

According to OpenAI, its internal AI system produced an analytical proof showing that a smooth, initially stationary fluid subject to a smooth external force can develop a singularity in finite time.

OpenAI also produced a formalized version of the argument using Lean, a computer-assisted mathematical proof system.

The proposed solution involves a vortex that spirals inward and becomes increasingly elongated. As the central region shrinks, the velocity increases while the total energy remains finite.

This behavior provides the mathematical mechanism needed for the claimed finite-time breakdown.

Thousands of AI Agents Worked Together

One of the most remarkable aspects of the announcement was the scale of the AI effort.

OpenAI says its system used approximately 10,000 concurrent agents during the Navier–Stokes investigation. The agents explored different approaches and exchanged intermediate results.

According to OpenAI's account, the agents reached their Navier–Stokes resolution on September 5, around 88 hours after the project began. Formalization and verification in Lean took an additional 17 hours.

The company says the broader project involved millions of AI-generated messages and hundreds of billions of output tokens.

Why Lean Formalization Matters

AI-generated mathematical reasoning can contain subtle mistakes. A convincing explanation is not automatically a correct proof.

That's why formal verification is important.

Lean allows mathematical statements to be expressed in a machine-checkable form. OpenAI says its Navier–Stokes result was accompanied by a Lean formalization.

This does not eliminate the importance of mathematicians. Researchers still need to examine the definitions, assumptions, formalization and whether the theorem actually corresponds to the intended Millennium Prize question.

Did OpenAI Solve the Original Problem?

This is where the story becomes more complicated.

OpenAI says its result establishes statements C and D in the official Millennium Prize formulation, involving a smooth external force.

Some discussions surrounding the announcement distinguish this from the more familiar unforced Navier–Stokes problem. A specialist tracker notes that the unforced three-dimensional global-regularity question remains open under that interpretation.

Therefore, headlines saying simply that "AI solved Navier–Stokes" can hide an important mathematical detail.

The exact formulation being solved matters enormously.

A New Era for AI Mathematics?

The announcement could nevertheless represent an important development.

Modern AI systems are increasingly capable of:

• Exploring mathematical possibilities
• Writing symbolic arguments
• Generating computer code
• Testing mathematical constructions
• Collaborating through multiple AI agents
• Producing machine-checkable proofs

Instead of asking one AI model to solve a problem from beginning to end, researchers can create systems in which many agents investigate different approaches and another system combines the strongest ideas.

That resembles a digital research team.

What About the Controversy?

The announcement also generated questions about how AI systems obtain mathematical ideas.

OpenAI reported that it began its Navier–Stokes effort after hearing rumors that major mathematical problems might have been solved. It later investigated whether unpublished outside work could have influenced its system and said its investigation found that particular prior work by NYU mathematician Tristan Buckmaster could not have influenced the result.

These issues highlight a broader challenge for AI-assisted science: proving that a mathematical result is correct is one question; establishing originality and appropriate credit is another.

What Happens Next?

The mathematical community will need to examine the proof carefully.

Important questions include:

1. Does every step of the argument hold?
2. Does the formalized proof correctly represent the mathematical claim?
3. Does the result satisfy the precise requirements of the Millennium Prize formulation?
4. How does the result relate to the unforced Navier–Stokes problem?
5. How should credit be assigned between AI systems and human researchers?

OpenAI itself says it does not intend to claim the Millennium Prize for the result.

The Bigger Picture

Whether this becomes universally recognized as the definitive solution or remains a major step requiring further mathematical interpretation, the announcement demonstrates how rapidly AI is entering advanced mathematical research.

For decades, solving problems like Navier–Stokes required human researchers to develop new ideas through years of mathematical work. AI systems are now being used to explore enormous numbers of possibilities in much shorter periods.

The most interesting question may therefore extend beyond Navier–Stokes:

Could AI eventually become a practical research partner capable of discovering, testing and formally proving new mathematics that humans would struggle to find on their own?

The Navier–Stokes episode offers one of the clearest tests yet of that possibility.

Conclusion

OpenAI's September 2026 announcement represents a potentially historic development in AI-assisted mathematics. Its system produced an analytical proof and Lean formalization for a finite-time singularity in a particular formulation of the Navier–Stokes problem.

However, "AI solved one of mathematics' greatest mysteries" needs to be understood with the precise mathematical formulation in mind. Independent scrutiny, verification, interpretation and recognition remain essential.

If the proof withstands that process, the achievement could mark a major turning point—not simply for fluid dynamics, but for the way mathematical discoveries are made.

 

Building AI Agents with llama.cpp: A Practical Guide for Developers

AI agents are becoming an important part of modern software development. Unlike a basic chatbot that simply responds to a prompt, an AI agent can break a goal into tasks, use tools, remember relevant information, execute actions and adjust its approach based on results.

One interesting way to build local AI agents is with llama.cpp. It is a lightweight C/C++ implementation designed to run large language models efficiently on a wide range of hardware, including systems without high-end GPUs.

This makes llama.cpp particularly interesting for developers who want to experiment with private, locally running AI agents.

What Is llama.cpp?

llama.cpp is an open-source project for running large language models locally. It began as an implementation focused on Meta's LLaMA models and has expanded to support many modern model architectures.

A major feature of llama.cpp is its use of the GGUF model format. GGUF packages model information and weights into a format designed for efficient local inference.

The project supports CPU execution as well as acceleration through several GPU backends.

Instead of sending every request to a cloud API, a developer can run a compatible model directly on their own computer or server.

What Makes llama.cpp Useful for AI Agents?

An AI agent normally consists of several components rather than just an LLM.

A simplified architecture looks like this:

User → Agent Controller → Local LLM → Tool Selection → Tool → Result → LLM → Final Response

llama.cpp provides the model-inference layer. The developer builds the surrounding agent logic.

For example, an agent could receive:

“Analyse this CSV and tell me which products had the biggest sales increase.”

The agent could:

1. Understand the request.
2. Decide that a data-analysis tool is needed.
3. Call a Python function.
4. Receive the calculated results.
5. Interpret those results.
6. Generate a natural-language response.

The local LLM provides the reasoning and language capabilities, while your application controls the tools and workflow.

---

Step 1: Install llama.cpp

The exact installation process depends on your operating system and whether you want CPU or GPU acceleration.

The project provides source code and build instructions through its official repository.

After building llama.cpp, you can use its command-line programs to load compatible GGUF models.

A typical workflow is conceptually:

Model (GGUF)
     ↓
llama.cpp
     ↓
Local inference
     ↓
Agent application

For production applications, you should choose the appropriate build and acceleration backend for your hardware.

---

Step 2: Choose a Model

The model is one of the most important parts of an AI-agent system.

When choosing a local model, consider:

• Parameter size
• Context length
• Instruction-following ability
• Tool/function-calling support
• Quantisation
• RAM requirements
• GPU memory
• Response speed
• Licence

For a personal computer, a smaller quantised model may be much more practical than a very large model.

What Is Quantisation?

Quantisation reduces the numerical precision used to represent model weights.

For example, instead of storing weights using higher-precision formats, a quantised model can use lower-bit representations.

The result can be:

• Smaller model files
• Lower memory requirements
• Faster local inference in some configurations

The trade-off is that aggressive quantisation can reduce model quality.

---

Step 3: Run the Model Locally

Once you have a compatible GGUF model, llama.cpp can load it and generate responses locally.

A simple command-line workflow can look like:

llama-cli -m model.gguf

The exact command-line options depend on your version and desired configuration.

You can then provide prompts directly to the local model.

At this stage, you have an LLM application, but not necessarily an AI agent.

That's an important distinction.

---

LLM vs AI Agent

A language model generally follows this pattern:

Prompt → Model → Response

An agent adds an orchestration layer:

Goal → Planning → Tool → Observation → Reasoning → Action → Result

For example, suppose the user asks:

“What is the current temperature in Delhi?”

A normal language model might attempt to answer from its existing knowledge.

An agent can instead decide:

I need a weather tool → call the tool → receive current weather → explain the result.

This is where application-level programming becomes important.

---

Step 4: Create the Agent Controller

The agent controller is the software that connects the model to external tools.

Python is a convenient choice for building a prototype.

A simplified architecture might look like:

class Agent:
    def __init__(self, model, tools):
        self.model = model
        self.tools = tools

    def run(self, task):
        # Send task to model
        # Determine whether a tool is required
        # Execute approved tool
        # Send result back to model
        # Return final response
        pass

The controller determines what the model is allowed to do.

This is important because an agent should not automatically receive unrestricted access to your computer.

---

Step 5: Give the Agent Tools

Tools are what transform a language model into something much more useful.

Examples include:

• Calculator
• Search system
• Database
• Python interpreter
• File reader
• Calendar
• Weather API
• Internal company API

For example:

def calculate(expression):
    # Validate the expression first
    return safe_calculation(expression)

The model can be instructed to request the calculator when mathematical computation is required.

The application then executes the function and returns the result.

---

Step 6: Use Structured Tool Calls

For reliable agents, avoid asking the model to produce arbitrary executable code whenever possible.

Instead, define structured tools.

For example:

{
  "name": "get_weather",
  "arguments": {
    "city": "Delhi"
  }
}

Your application can validate this request before calling the actual weather service.

This provides a much safer architecture than allowing the model to execute unrestricted commands.

---

Step 7: Build a Simple Agent Loop

A basic agent loop can be represented as:

1. Receive user request
        ↓
2. Send request to LLM
        ↓
3. Check whether a tool is requested
        ↓
4. Validate tool request
        ↓
5. Execute tool
        ↓
6. Return tool result to LLM
        ↓
7. Generate final response

This loop can be extended with multiple tools and multiple reasoning steps.

For example, a research agent might:

Question
   ↓
Search
   ↓
Collect information
   ↓
Analyse information
   ↓
Check results
   ↓
Write report

The developer determines how many iterations are permitted.

---

Step 8: Add Memory

An agent can also maintain information from previous interactions.

There are several types of memory.

Short-term memory

The current conversation can be included in the model's context.

Long-term memory

Important information can be stored externally and retrieved when necessary.

A vector database can be used for semantic retrieval.

For example:

User asks question
       ↓
Search memory
       ↓
Retrieve relevant information
       ↓
Add information to context
       ↓
Local LLM generates response

However, storing personal or sensitive information requires careful privacy and security controls.

---

Step 9: Add Retrieval-Augmented Generation

Retrieval-Augmented Generation, or RAG, allows an agent to retrieve information from external documents before generating an answer.

Suppose you are building an agent for a company's documentation.

The workflow could be:

User Question
     ↓
Embedding / Search
     ↓
Relevant Documents
     ↓
Context
     ↓
llama.cpp Model
     ↓
Answer

This can be useful because the model doesn't have to rely entirely on information encoded in its parameters.

It can instead reference an approved knowledge base.

---

Step 10: Give Agents Limited Permissions

This is one of the most important principles when building local agents.

An agent running on your computer can potentially interact with files, processes or other resources if your application gives it those capabilities.

Therefore, use least privilege.

For example, instead of giving an agent access to your entire computer:

Agent
 ↓
/project/data/

give it access only to the directory it actually needs.

Similarly, a database agent should ideally have restricted permissions rather than unrestricted administrative access.

---

Building a Data-Science Agent

llama.cpp can be particularly interesting for local data-analysis assistants.

Imagine an agent with these tools:

Local LLM
   │
   ├── CSV reader
   ├── Python analysis
   ├── SQL database
   ├── Chart generator
   └── Report writer

A user could ask:

“Analyse this sales dataset and identify unusual monthly changes.”

The agent could:

1. Inspect the dataset.
2. Calculate summary statistics.
3. Identify relevant columns.
4. Run approved analysis code.
5. Generate charts.
6. Explain the findings.

The important part is that the agent controller should validate each action rather than blindly executing model-generated instructions.

---

Performance Considerations

Running an AI agent locally introduces several performance considerations.

RAM

Larger models require more memory. Quantised models can reduce the memory requirement.

GPU

GPU acceleration can significantly improve inference speed when supported by your hardware and llama.cpp build.

Context Length

Long conversations and large retrieved documents require more memory and computation.

Number of Agent Steps

An agent that performs ten tool calls will generally take longer than one that performs a single action.

Therefore, efficient agent design is important.

---

Why Use llama.cpp for Local Agents?

There are several reasons developers may choose llama.cpp.

Privacy

Data can remain on infrastructure controlled by the developer, subject to the security of that infrastructure.

Offline Capability

A suitable local model can operate without continuously sending prompts to a cloud service.

Customisation

Developers can control the surrounding application, tools and workflow.

Cost Control

Local inference can reduce per-request API expenses, although hardware and electricity still have costs.

Learning

Building a local agent is an excellent way to understand how LLM applications actually work.

---

Challenges of Building Agents With llama.cpp

Local AI agents also have limitations.

Hardware requirements

Large models can require substantial RAM or GPU memory.

Model quality

Smaller local models may not match the strongest cloud models on every task.

Tool reliability

An agent can select an inappropriate tool or produce invalid arguments.

Hallucinations

A model can generate information that isn't supported by its available evidence.

Complex orchestration

As the number of tools increases, managing agent state and errors becomes more difficult.

Security

Giving an AI system access to files, databases or operating-system commands introduces additional security risks.

---

Best Practices

When building an AI agent with llama.cpp, consider the following practices:

Start small: Begin with one model and one or two tools.

Use structured outputs: Make tool requests machine-readable and validate them.

Limit permissions: Give the agent only the access it requires.

Set execution limits: Prevent uncontrolled loops and excessive tool calls.

Log actions: Record important agent decisions and tool calls.

Validate results: Don't assume that generated answers are correct.

Protect sensitive data: Avoid exposing unnecessary personal, confidential or private information.

Test failure cases: See what happens when a tool fails, returns incorrect information or produces unexpected output.

---

Example Architecture

A practical local AI-agent system might look like this:

                 ┌─────────────────┐
                 │     User        │
                 └────────┬────────┘
                          ↓
                 ┌─────────────────┐
                 │ Agent Controller│
                 └────────┬────────┘
                          ↓
                 ┌─────────────────┐
                 │    llama.cpp    │
                 │   Local Model   │
                 └────────┬────────┘
                          ↓
             ┌────────────┼────────────┐
             ↓            ↓            ↓
        Calculator      RAG         Python
             │            │            │
             └────────────┼────────────┘
                          ↓
                 ┌─────────────────┐
                 │   Final Result  │
                 └─────────────────┘

This architecture separates the language model from the tools and application logic.

---

Future of Local AI Agents

The combination of efficient local inference and agent-based software could make AI assistants increasingly accessible.

Instead of one general chatbot, developers can build specialised agents for:

• Programming
• Data analysis
• Research
• Document processing
• Customer support
• Personal productivity
• Software testing
• Local knowledge bases

As local models become more capable and inference becomes more efficient, developers may be able to build increasingly sophisticated applications without depending entirely on cloud-based AI services.

Conclusion

Building AI agents with llama.cpp involves more than simply downloading a model and sending it prompts. llama.cpp provides the local inference foundation, while the developer builds the agent controller, tools, memory, retrieval system and safety mechanisms around it.

A good starting architecture is:

llama.cpp + GGUF model + Agent Controller + Tools + RAG + Validation

Start with a simple workflow, give the agent narrowly defined capabilities, validate tool calls and gradually add more functionality.

The most useful local AI agent is not necessarily the one with the most tools. It is the one that can reliably perform a clearly defined task while keeping the developer in control of its actions.

 

Agentic AI Hands-On in Python: A Video Tutorial

Agentic AI is becoming one of the most exciting areas of artificial intelligence. Traditional AI applications usually respond to a prompt and produce an answer. Agentic AI goes a step further by allowing an AI system to plan tasks, use tools, inspect results and complete multi-step workflows.

Python is particularly suitable for experimenting with agentic AI because it has a large ecosystem for machine learning, APIs, data processing and automation.

This hands-on tutorial explains how to build a simple AI agent in Python and how the same concepts can be demonstrated in a video tutorial.

What Is Agentic AI?

Agentic AI refers to AI systems designed to accomplish goals by taking multiple steps rather than simply generating one response.

A simplified workflow looks like this:

Goal → Plan → Choose Tool → Execute → Observe → Continue → Result

For example, imagine asking an AI agent:

“Analyse this sales file and tell me which product had the biggest increase.”

An agent could:

1. Read the file.
2. Inspect the columns.
3. Calculate sales changes.
4. Identify the relevant product.
5. Explain the result.

The important feature is that the system can perform actions as part of completing the task.

Why Use Python?

Python is a natural choice for agentic-AI development because developers can combine an AI model with ordinary Python functions.

For example, an agent can have access to tools such as:

def calculator(a, b):
    return a + b

or:

def get_customer(customer_id):
    # Retrieve approved customer information
    return customer_id

The AI determines when a tool may be useful, while the Python application controls whether and how that tool is executed.

This separation is important for reliability and security.

What You Need for the Tutorial

For a beginner-friendly project, you can use:

• Python 3
• A code editor such as VS Code
• An AI model or compatible API
• A Python environment
• A few simple tools
• Basic Python knowledge

You don't need to begin with a complicated multi-agent system. A single agent with one or two tools is enough to understand the fundamental concepts.

Step 1: Create a Python Project

Create a project directory:

agentic-ai-demo/
│
├── agent.py
├── tools.py
└── requirements.txt

Creating a virtual environment is recommended so that project dependencies remain isolated.

A typical setup can be:

python -m venv .venv

Activate the environment according to your operating system.

Then install the libraries required by the particular AI framework or model provider you choose.

Step 2: Understand the Agent Architecture

Before writing code, it helps to understand the basic components.

                 USER
                   ↓
             AGENT CONTROLLER
                   ↓
              AI MODEL
             ↙    ↓    ↘
        Tool A  Tool B  Tool C
             ↘    ↓    ↙
                RESULT
                   ↓
              FINAL ANSWER

The model interprets the request.

The agent controller manages the workflow.

The tools perform actions.

The results are returned to the model so it can continue processing the task.

Step 3: Create Your First Tool

Let's create a simple calculator tool.

def add_numbers(a, b):
    return a + b

We can test it normally:

result = add_numbers(10, 20)

print(result)

The output is:

30

This may look very simple, but tools are fundamental to agentic applications.

A real project might replace the calculator with:

• A database query
• A search function
• A document retriever
• A weather service
• A file-processing function
• A data-analysis function

Step 4: Connect an AI Model

The next step is connecting the agent to an AI model.

The exact Python code depends on the model or provider you use. Modern AI platforms commonly provide Python SDKs or APIs that allow an application to send messages and receive model responses.

Conceptually:

response = model.generate(
    "Calculate the total sales."
)

print(response)

The model receives the user's request and produces a response.

At this stage, however, it may not actually be using tools.

Step 5: Add Tool Calling

Tool calling allows the model to request a particular function.

Imagine the user asks:

“What is 125 multiplied by 8?”

The model could determine that a calculator tool is appropriate.

The workflow becomes:

User
 ↓
AI Model
 ↓
Calculator Tool
 ↓
Calculation Result
 ↓
AI Model
 ↓
Answer

Your Python application controls the actual function call.

A simplified representation might look like:

tool_result = calculator(125, 8)

final_answer = model.generate(
    f"The calculator returned {tool_result}. Explain the result."
)

Production implementations normally use structured tool definitions instead of manually constructing strings.

Step 6: Build the Agent Loop

The agent loop is the core of many agentic applications.

A simplified version looks like:

while True:
    response = model.generate(task)

    if response.requires_tool:
        result = execute_tool(response.tool)
        task = result
    else:
        break

The exact implementation varies considerably between frameworks.

The important idea is that the model can receive information from a tool and use that information in the next step.

Step 7: Create a Data-Analysis Agent

Python becomes particularly powerful when we combine AI agents with data-science libraries.

Suppose we have:

sales.csv

containing:

Product,January,February,March
Laptop,120,150,180
Tablet,200,190,230
Phone,300,350,400

A Python function can read the data:

import pandas as pd

def load_sales():
    return pd.read_csv("sales.csv")

We could create another function to calculate changes:

def calculate_growth(df):
    df["Growth"] = df["March"] - df["January"]
    return df

The agent could then use these functions as part of a larger analytical workflow.

Step 8: Add Memory

A useful agent often needs some form of memory.

There are two broad categories.

Short-term memory

This includes information from the current conversation or task.

Long-term memory

Information is stored externally and retrieved when needed.

For example:

User Question
      ↓
Memory Search
      ↓
Relevant Information
      ↓
AI Model
      ↓
Response

Vector databases and embedding-based retrieval are commonly used for semantic memory systems.

Step 9: Add RAG

Retrieval-Augmented Generation, commonly called RAG, allows an agent to retrieve relevant information from documents.

Imagine creating a school or company knowledge assistant.

The user asks:

“What is the refund policy?”

Instead of expecting the model to know the answer, the agent can search an approved document collection.

Question
   ↓
Retriever
   ↓
Relevant Documents
   ↓
AI Model
   ↓
Answer

This approach can make knowledge-based applications more useful because the model receives relevant external context.

Step 10: Make the Video Tutorial Hands-On

A good video tutorial should not spend the entire time explaining theory.

A practical structure could be:

00:00 — Introduction

Explain what agentic AI means and show the finished application.

02:00 — Project Setup

Install Python, create the project and configure the environment.

05:00 — Understanding Agents

Explain the relationship between the model, controller and tools.

08:00 — Create the First Tool

Build a simple Python function.

12:00 — Connect the AI Model

Demonstrate the model interaction.

17:00 — Implement Tool Calling

Show how the model can request a tool.

23:00 — Build the Agent Loop

Connect multiple steps into a workflow.

28:00 — Add Data Analysis

Use Python to analyse a sample dataset.

35:00 — Add Memory or RAG

Demonstrate retrieval from a small document collection.

42:00 — Testing

Try successful requests and deliberately test failure cases.

47:00 — Security and Limitations

Explain why unrestricted agent access is dangerous.

50:00 — Final Project

Demonstrate the completed agent from start to finish.

Step 11: Test the Agent

Testing is one of the most important parts of agent development.

Try straightforward requests first:

Calculate 50 + 75.

Then test more complex requests:

Read the sales data and identify the largest increase.

Finally, test unexpected inputs:

Use an unavailable tool.

Analyse a file that doesn't exist.

The goal is to discover how the agent behaves when things go wrong.

Security Should Be Part of the Tutorial

An AI agent can become risky if it receives unrestricted access to a computer.

Avoid giving an experimental agent unrestricted capabilities such as:

• Executing arbitrary shell commands
• Deleting files
• Accessing private credentials
• Modifying production databases
• Sending messages without approval

Instead, use controlled tools with clearly defined inputs and outputs.

For example:

AI Agent
   ↓
Approved Tool
   ↓
Input Validation
   ↓
Action
   ↓
Result

Human approval can also be required for high-impact operations.

Common Beginner Mistakes

Giving the agent too many tools

Start with one or two tools. Complexity grows quickly as more tools are added.

Trusting generated code blindly

Always review and test code produced by an AI system.

Ignoring error handling

Tools can fail because of invalid input, network problems or missing files.

Using unlimited loops

Set sensible limits on the number of agent steps.

Forgetting data privacy

Don't send confidential information to an AI service unless you have appropriate permission and safeguards.

Confusing chatbots with agents

A chatbot can answer questions without performing actions. An agent generally combines a model with tools and an orchestration workflow.

A Simple Agent Project Idea

After completing the tutorial, you can extend the project into a Personal Data Assistant.

The architecture could be:

                 Personal Data Assistant
                          │
                 ┌────────┴────────┐
                 │   AI Model      │
                 └────────┬────────┘
                          │
          ┌───────────────┼───────────────┐
          ↓               ↓               ↓
       CSV Tool        Calculator       RAG
          │               │               │
          └───────────────┼───────────────┘
                          ↓
                     Final Answer

The assistant could answer questions about approved datasets, perform calculations and retrieve information from selected documents.

This project provides a practical introduction to tool calling, retrieval, Python automation and agent orchestration.

What's Next?

Once the basic agent works, you can experiment with more advanced concepts:

• Multi-agent systems
• Planning agents
• Browser-based agents
• Coding agents
• RAG agents
• AI research assistants
• Workflow automation
• Local LLM agents
• Agent evaluation
• Human-in-the-loop systems

The important thing is to increase complexity gradually.

Conclusion

Building an AI agent in Python is an excellent way to understand how modern AI applications work beyond simple chat interfaces. The core idea is straightforward: combine an AI model with carefully designed tools and an application layer that controls the workflow.

A beginner project can start with a single Python function and gradually evolve into a system capable of retrieving information, analysing data and completing multi-step tasks.

For a video tutorial, the most effective approach is to build the project live—from environment setup to the final working agent—while explaining each component along the way.

Python provides the building blocks; the AI model provides language and reasoning capabilities; and the agent controller connects everything into an actionable workflow.

 

How I Use AI Agents as a Data Scientist in 2026

Artificial intelligence is changing the way data scientists work. In 2026, AI agents are becoming useful partners for tasks that previously required hours of manual effort, from exploring datasets and writing code to monitoring machine-learning experiments and preparing reports.

An AI agent is more than a chatbot that answers questions. An agent can receive a goal, break it into smaller tasks, use tools, examine results, and take further actions based on what it discovers. For data scientists, this creates an opportunity to automate repetitive parts of the analytical workflow while keeping humans responsible for important decisions.

Here is how I would use AI agents throughout a modern data-science workflow.

1. Starting With a Data Question

Every data-science project begins with a question.

For example:

“Why did customer churn increase during the last quarter?”

Instead of immediately opening a notebook and manually exploring dozens of columns, I can give an AI agent a clearly defined analytical objective.

The agent can help turn the broad question into smaller tasks:

• Identify relevant datasets.
• Examine available columns.
• Check data quality.
• Calculate important statistics.
• Look for unusual patterns.
• Suggest possible hypotheses.
• Prepare an initial analysis plan.

This does not mean accepting the agent's plan automatically. I treat it as a starting point and verify whether the proposed approach makes sense for the business problem.

2. Data Discovery and Profiling

Finding useful information in large datasets can consume significant time.

An AI agent can assist by examining schemas and generating a data profile containing information such as:

• Number of rows and columns
• Data types
• Missing values
• Duplicate records
• Unique categories
• Numerical distributions
• Potential outliers
• Relationships between variables

For example, if a dataset contains customer information, an agent might identify columns such as customer_id, subscription_type, monthly_spend, login_frequency and churn_status.

The agent can then suggest which variables may deserve further investigation.

However, I still verify the results because automated profiling can misunderstand the meaning of a column or overlook domain-specific problems.

3. Cleaning Data With AI Assistance

Data cleaning is one of the most time-consuming parts of data science.

AI agents can help generate code for common operations such as:

df = df.drop_duplicates()

df["age"] = df["age"].fillna(df["age"].median())

df["category"] = df["category"].str.strip().str.lower()

An agent can also identify suspicious values and suggest possible treatments.

For example, if most customer ages are between 18 and 80 but some records contain values such as 250, the agent can flag them for investigation.

The important distinction is that flagging a problem and deciding how to fix it are different tasks.

I would not allow an agent to blindly modify an important production dataset. Instead, I review the proposed transformations and maintain reproducible data-cleaning code.

4. Generating Exploratory Data Analysis

Exploratory data analysis, or EDA, helps uncover patterns before building a model.

AI agents can generate Python code for:

• Histograms
• Scatter plots
• Correlation matrices
• Box plots
• Time-series charts
• Grouped statistics
• Distribution comparisons

For example:

import matplotlib.pyplot as plt

plt.hist(df["monthly_spend"])
plt.xlabel("Monthly Spend")
plt.ylabel("Customers")
plt.title("Customer Spending Distribution")
plt.show()

The agent can also suggest which visualisations might answer a particular analytical question.

This can speed up experimentation considerably. But visual interpretation remains important. A chart may reveal a correlation without proving that one variable causes another.

5. Writing and Debugging Python

One of my most practical uses for AI agents is programming assistance.

Instead of spending a long time searching for a syntax error, I can provide the agent with:

• The code
• The error message
• The expected result
• Relevant information about the dataset

The agent can then explain the problem and propose a correction.

It can also help create reusable functions, SQL queries and data-processing pipelines.

For example, I might ask an agent to create a function that calculates customer retention by month. I can then test the generated code against known results.

The agent becomes a coding assistant rather than an unquestioned programmer.

6. Working With SQL

Many data-science projects involve databases containing millions or billions of records.

AI agents can translate analytical questions into SQL.

For example:

SELECT
    subscription_type,
    COUNT(*) AS customers,
    AVG(monthly_spend) AS average_spend
FROM customers
GROUP BY subscription_type;

An agent can also explain complicated queries and suggest ways to improve readability or performance.

For large production systems, however, I would validate the generated query carefully. A syntactically correct query can still produce the wrong business result.

7. Feature Engineering

Feature engineering involves transforming raw information into useful model inputs.

An AI agent can suggest possible features based on the structure of a dataset.

For a customer-churn problem, examples could include:

• Days since last login
• Average monthly usage
• Number of support requests
• Spending trend
• Subscription duration

The agent can generate candidate features and code for calculating them.

But feature selection should involve domain knowledge and statistical validation. Creating hundreds of automatically generated features can increase complexity and potentially introduce leakage or overfitting.

8. Building Machine-Learning Experiments

AI agents can also help organise machine-learning experiments.

Given a classification problem, an agent might prepare experiments involving:

• Logistic regression
• Decision trees
• Random forests
• Gradient boosting
• Neural networks

It can create training scripts, evaluation functions and experiment configurations.

A simplified workflow could look like:

Dataset → Cleaning → Feature Engineering → Train/Test Split → Model Training → Evaluation → Experiment Tracking

The agent can automate repetitive portions of this process while I focus on interpreting the results.

9. Comparing Model Performance

When several models are trained, an AI agent can collect evaluation metrics and create comparison tables.

For classification, these might include:

• Accuracy
• Precision
• Recall
• F1 score
• ROC-AUC

For regression:

• MAE
• MSE
• RMSE
• R²

The agent can explain differences between experiments and identify which models deserve additional investigation.

Importantly, I don't select a model purely because an agent says it is “best.” The appropriate metric depends on the actual problem, business costs and consequences of errors.

10. Automating Repetitive Analysis

One of the biggest advantages of agents is their ability to handle multi-step workflows.

For example, a weekly sales-analysis agent could:

1. Retrieve the latest approved dataset.
2. Check for data-quality issues.
3. Calculate predefined metrics.
4. Generate charts.
5. Compare results with previous periods.
6. Flag unusual changes.
7. Prepare a draft report.

This turns a repetitive manual workflow into a semi-automated process.

The human still reviews important outputs before they are distributed.

11. Monitoring Machine-Learning Models

Deploying a model is not the end of a data-science project.

Model performance can change as real-world data changes. AI agents can assist with monitoring by checking predefined indicators such as:

• Prediction distributions
• Input-data drift
• Missing-value rates
• Model performance
• Error rates
• Data pipeline failures

If an unusual change occurs, an agent can summarise what happened and create an alert for the responsible team.

For critical applications, automated alerts should not automatically trigger consequential decisions without appropriate human oversight.

12. Research and Documentation

Data scientists spend considerable time reading technical documentation and research papers.

AI agents can help organise this information by summarising concepts, comparing approaches and extracting implementation requirements.

For example, when investigating a new machine-learning technique, I can ask an agent to structure my research around:

• What problem does the method solve?
• What data does it require?
• What assumptions does it make?
• How computationally expensive is it?
• What are its limitations?
• How could it be tested?

This makes research more structured, although original papers and authoritative documentation should remain the source of truth for important technical details.

13. Creating Data Reports

Once an analysis is complete, communicating the results is just as important as performing the analysis.

An AI agent can help convert analytical outputs into a structured report containing:

• Executive summary
• Key findings
• Supporting charts
• Important limitations
• Recommended areas for further investigation

I still check every important number before publishing the report. AI systems can occasionally produce plausible-looking statements that are not supported by the underlying data.

14. Using Agents Without Losing Control

The most important lesson is that AI agents should assist data scientists rather than replace analytical judgement.

I use a simple principle:

AI generates → AI checks → Human verifies → Human decides

This approach is especially important when working with sensitive information.

Before giving an agent access to a dataset, I consider:

• Does the agent actually need the data?
• Is personal information included?
• Where will the data be processed?
• Who can access the generated results?
• What permissions does the agent have?
• Can its actions be audited or reversed?

Limiting permissions is particularly important for autonomous systems.

15. My 2026 Data-Science Agent Workflow

A practical workflow can look like this:

Step 1: Define the analytical question.

Step 2: Give the agent access only to the required data and tools.

Step 3: Ask it to inspect and profile the dataset.

Step 4: Review the proposed data-cleaning process.

Step 5: Generate EDA code and visualisations.

Step 6: Develop candidate features.

Step 7: Run controlled machine-learning experiments.

Step 8: Evaluate the results using appropriate metrics.

Step 9: Ask the agent to document the experiment.

Step 10: Human review and final interpretation.

This workflow allows AI to handle repetitive tasks while keeping analytical responsibility with the data scientist.

Benefits of AI Agents for Data Scientists

The main advantages I see are:

Faster experimentation

Agents can generate boilerplate code and analytical workflows quickly.

Less repetitive work

Routine profiling, reporting and documentation can be partially automated.

Better accessibility

People can describe analytical goals in natural language before converting them into SQL or Python.

More systematic workflows

Agents can follow predefined procedures for recurring tasks.

Faster debugging

Coding errors and failed experiments can often be investigated conversationally.

Challenges to Keep in Mind

AI agents are powerful, but they are not automatically reliable.

Potential problems include:

• Incorrect generated code
• Misinterpretation of data
• Hallucinated explanations
• Poor statistical assumptions
• Data leakage
• Security risks
• Privacy concerns
• Excessive automation
• Reproducibility problems

A particularly dangerous situation is when an agent produces a convincing explanation for an incorrect result.

That is why testing, validation and human review remain essential.

Conclusion

In 2026, I see AI agents as an additional layer in the data scientist's toolkit. They can help with data exploration, Python programming, SQL, feature engineering, machine-learning experiments, monitoring, research and reporting.

The biggest productivity gain does not necessarily come from allowing an agent to do everything autonomously. Instead, it comes from assigning agents well-defined tasks, giving them appropriate tools and permissions, and continuously checking their work.

The future data scientist may spend less time writing repetitive code and more time asking better questions, validating evidence, understanding business problems and making informed analytical decisions.

AI agents can automate parts of the workflow—but the responsibility for trustworthy data science still belongs to the human.