The Death of ETH? Inside the AI Disproof Shaking Theoretical Computer Science
By Muizz Shaikh | FourfoldAI Research Team | Last updated: November 6, 2026
In late October 2026, two AI labs announced that they had overturned the Exponential Time Hypothesis (ETH), a 1999 conjecture that says 3-SAT cannot be solved in subexponential time. OpenAI went first on October 26. Anthropic followed within hours with a paper credited to Claude.
Both labs say an internal model found a deterministic algorithm. Both published Lean 4 formalizations alongside their papers. The researchers who proposed ETH, Russell Impagliazzo and Ramamohan Paturi, are now helping to check the work.

Before anything else, one point needs to be nailed down. A subexponential algorithm is not a polynomial-time algorithm. Refuting ETH does not prove P = NP, and the lab claims do not say it does.
So here is the thesis of this report. Something real happened: two independent AI-found algorithms, each with a machine-checked proof, now sit in public repositories. But "AI disproved ETH" compresses four separate claims into one headline, and each carries a different level of evidence. We take them apart one at a time.
Key Findings: Did AI Really Disprove ETH?
Two AI-generated papers claim a deterministic subexponential algorithm for counting satisfying assignments of 3-SAT, and both ship Lean 4 proofs. No peer review is finished, expert review is under way, and Lean checks only a slightly weaker bound for OpenAI. The algorithms offer no practical speedup.
That is the executive answer. The table below tracks where each claim stands as of November 6, 2026.
Dimension | OpenAI Result | Anthropic Result | Current Community Verdict |
Claim | Deterministic algorithm for counting k-SAT solutions in 2^(O(n·loglog n/√log n)) time | Same-shaped bound for #3-SAT, so decision 3-SAT is also 2^(o(n)) | Plausible, not peer-reviewed |
Lean 4 code public | Yes, in the openai/math repository | Yes, in the anthropics/formal-math repository | Public and re-runnable |
Formal statement vs. headline | Lean checks a weaker exponent, n(loglog n)²/√log n | Repository says the Lean main theorem states the paper's counting result | OpenAI gap documented; Anthropic statement fidelity still needs human audit |
Real-world acceleration | None claimed | Paper and README say the result is purely asymptotic | None expected; constants are enormous |

Methodology: How We Audited the Claims
We sorted every claim into four levels and refused to let evidence at one level stand in for another. Level 1 is an informal paper claiming a subexponential algorithm. Level 2 is a Lean 4 file the kernel accepts without axioms beyond standard Mathlib. Level 3 is semantic fidelity: does the formal statement say what the paper says? Level 4 is practical performance against modern CDCL solvers.
We opened the arXiv pages for the Dias–Lima and MIT papers, the Anthropic repository documentation, and a community reproduction of OpenAI's Lean build. We did not re-derive either proof, and details of the 67-page and 49-page papers come from abstracts, repository documentation and expert commentary, not a line-by-line reading. Where sources disagree, we show both.
The Bedrock of Fine-Grained Complexity
What Is the Exponential Time Hypothesis?
The Exponential Time Hypothesis says that 3-SAT, the problem of satisfying formulas built from three-literal clauses, needs time that grows exponentially in the number of variables, so no 2^(o(n)) algorithm exists. Impagliazzo and Paturi proposed it in 1999, and Impagliazzo, Paturi and Zane elaborated it in 2001. Formally, there is some constant ε > 0 such that no algorithm solves n-variable 3-SAT in 2^(εn) time.
A 3-SAT instance has Boolean variables and clauses of three literals each. You want one assignment that makes every clause true. Richard Karp showed in 1972 that this problem is NP-complete.
NP-completeness, though, only speaks about polynomial time. It says nothing about how bad the best algorithm's running time must be. ETH fills that gap by betting on genuinely exponential growth.
Why Did Computer Scientists Rely on It?
Researchers leaned on ETH because it converts one unproven belief into tight, checkable lower bounds for hundreds of problems. The Sparsification Lemma of Impagliazzo, Paturi and Zane shows that a subexponential 3-SAT algorithm would give one for every k-SAT, and a linear-size reduction from 3-SAT to some other problem then forbids a subexponential algorithm there too. Graph coloring, Hamiltonian cycle, clique, vertex cover and many treewidth-based dynamic programs got "no faster than this" results that way. A refutation weakens the foundation under all of them.
Impagliazzo himself called ETH a "principled educated guess" in a 2012 lecture and said he and Paturi regarded it as roughly a coin flip.
The Family Tree: ETH, SETH, #ETH and Weak ETH
Hypothesis | What it asserts | Role |
ETH | 3-SAT has no 2^(o(n)) algorithm | Backbone of exponential-time lower bounds |
SETH (Strong ETH) | As k grows, k-SAT's best running time approaches 2^n | Source of polynomial lower bounds for Edit Distance, Orthogonal Vectors and similar |
The counting version: tallying 3-SAT solutions needs exponential time | Lower bounds for counting problems | |
Weak ETH | 3-SAT has no O(2^(n^(1−ε)))·poly-time algorithm for any ε > 0 | Fallback hypothesis, shown equivalent to SH in November 2026 |
SH (Satisfiability Hypothesis) | Stearns and Hunt's 1990 hypothesis, equivalent to Weak ETH | Candidate replacement foundation |
OpenAI's Claimed ETH Refutation
What Exactly Did OpenAI Publish?
OpenAI published a 67-page preprint titled "The Exponential Time Hypothesis is False," claiming a deterministic algorithm that counts satisfying assignments of any fixed-k CNF formula in 2^(O(n·loglog n/√log n)) time. The company says its model produced the natural-language proof on October 16 and a Lean formalization followed on October 17. The repository version is dated October 25, and the public announcement came October 26. Reviewers include Russell Impagliazzo, Ramamohan Paturi and Ryan Williams.
None of this is peer-reviewed. Williams told TechCrunch that parts looked routine but two or three "alien-looking" parts deserved collective attention, according to Wikipedia's summary of the coverage. Lance Fortnow wrote that the algorithm covers k-SAT and not NP in general.
Why Does Counting Matter More Than Deciding?
Counting is harder than deciding, so a subexponential counting algorithm is a stronger result than a subexponential decision algorithm. Decision 3-SAT asks whether any satisfying assignment exists. #3-SAT asks for the total number, and counting problems of this type are #P-complete. An algorithm that counts can always answer the yes/no question by checking whether the count is zero.
So OpenAI's use of counting does not weaken the claim. It makes the claim sturdier, and it refutes both ETH and its counting twin, #ETH.
The Algorithmic Idea
We can describe the structure only at a high level. As Dias and Lima summarize it, the preprint's body builds an interpolation algorithm: it deforms the counting problem into a family of easier ones, evaluates enough of them, and recovers the true count by interpolating back. The sharper headline bound comes from a different route, contracting Boolean tensor networks in the preprint's Appendix D.
Imagine a lock with a thousand dials. Brute force tries every combination. This method instead measures a few carefully chosen summaries of the lock and reconstructs the answer by algebra.
The Exponent Discrepancy
The paper's headline exponent is n·loglog n/√log n, but the Lean proof certifies the looser n·(loglog n)²/√log n. The gap comes from where each bound is proved: the sharper bound sits in the tensor-contraction appendix, while the weaker one belongs to the interpolation algorithm in the body. OpenAI's own Lean scope note documents the difference, and a community reproduction confirms the Lean theorem matches the weaker bound.
Why it matters: both bounds are still 2^(o(n)), so the weaker one alone refutes ETH. But a formal-completeness claim means the machine checked what the headline says. For OpenAI's headline bound, that part is still human-reviewed mathematics.
A third-party reproduction also notes that the final inference, from o(n) in the exponent to "ETH is false," is a trivial informal step, not a Lean theorem. That is a small point. It shows how many places a "verified" label can hide an informal seam.
Anthropic's Independent 3-SAT Algorithm
How Did Claude Find It?
Anthropic says an internal Claude research model found the core algorithm on October 16 using about 14 million output tokens and no human input, and researchers then helped polish the presentation. The paper, "A 2^o(n) Time Algorithm for 3-SAT," runs 49 pages. It is dated October 26, and the repository entry became widely visible on October 27 UTC.
A line in Anthropic's README claims Claude Opus 5.5 at high effort can rederive the refutation from a condensed description. That is a company claim, and we have not tested it.
How Does It Differ From OpenAI's Approach?
It does not differ in the way many summaries say: Anthropic's algorithm is also deterministic and also counts, solving #3-SAT in 2^(O(n·loglog n/√log n)) time. Some briefings describe it as a randomized decision algorithm later derandomized. Anthropic's own README says otherwise, and we follow the README.
The real differences are in the machinery. A community write-up reports that OpenAI's route uses deformation and Hermite interpolation, while Claude's uses a grid construction with an eight-square identity and a recursion with a 11/12 factor. We treat that comparison as secondary-source and unconfirmed by us.
The Lean story differs too. Anthropic's repository pins Lean v4.33.1 and the matching Mathlib, states its main theorems on Mathlib's Turing machines, and runs a tool called Comparator that checks the formal statements against a challenge file and re-checks proofs with a second, independently written kernel named nanoda. The README lists only Lean's three standard axioms.
The Significance, and the Danger, of Two Confirmations
Two independent algorithms strengthen the case that the underlying mathematical obstacle is real, but they do not make the result verified. Both labs report discovery on the same day, October 16. Both papers cite each other as concurrent and independent.
That is encouraging, and it is also a warning. Two systems trained on overlapping human mathematics, each producing a long argument few people can read quickly, can share a blind spot as easily as a truth. Agreement between machines is evidence. It is not an audit.
Head-to-Head Technical Comparison
Axis | OpenAI | Anthropic |
Problem target | Counting k-SAT, which also decides it | Counting 3-SAT, which also decides it |
Headline exponent | n·loglog n/√log n (general); n/√log n at bounded density | n·loglog n/√log n per README |
Lean-certified exponent | Weaker: n(loglog n)²/√log n | Main theorem as stated, per README |
Determinism | Deterministic | Deterministic |
Axiom dependencies | Community static audit found no extra axioms and no sorry in the proof's closure | Lean's three standard axioms |
Statement-check tooling | Comparator challenge file | Comparator plus nanoda second kernel |
Discovery | Oct 16, model output; Lean Oct 17 | Oct 16, 14M output tokens, no human input |
Peer scrutiny | Impagliazzo, Paturi, Williams reviewing | Same expert effort covers both claims |
Both algorithms run in time bounded by polynomial factors times a subexponential term, and neither claims to handle all of NP. On mechanism, the differences are algebraic: interpolation and tensor networks on one side, a grid and recursion on the other. On treewidth, Dias and Lima show the clause-product form of OpenAI's interpolation scheme degrades badly, a point we return to below.
Fortnow noted that getting subexponential algorithms for all of NP would take a 3-SAT algorithm running in 2^(n^(o(1))), which OpenAI's result does not approach.

The Mechanics of Lean 4 Formal Verification
How Does the Lean 4 Microkernel Verify Proofs?
Lean 4 verifies a proof by having a small trusted kernel type-check a complete proof term, regardless of how clever the tactics were that produced it. Tactics, automation and AI-written code can all be enormous and messy. The kernel only asks whether the final term is a valid derivation of the stated theorem from the axioms.
That design is why a 547,000-line proof library can still be trusted in principle: you trust the small checker, not the author. Lean's standard axioms are propositional extensionality, classical choice and quotient soundness. A proof that depends on anything beyond them should be flagged immediately.
The Specification Gaming Trap
A passing Lean check proves that the formal statement is true, not that the formal statement matches the claim in the headline. Anthropic's own repository says as much: Lean checks proofs, but no machine checks that the file says what the paper says.
Definitions can hide bugs. A cost model might let a "Turing machine" cheat by reading input in free bulk. A satisfiability predicate might be accidentally trivial. An encoding could smuggle in the answer. In each case, Lean would accept a true but irrelevant theorem.
Both labs use mitigations. OpenAI documents its formal scope in a note that specifies canonical input encodings and a polynomial bound on tape cells visited at every execution prefix. Anthropic states its theorems on Mathlib's Turing machines. Both use Comparator-style tooling. None of that replaces expert reading.
Verification Checklist for Independent Auditors
Statement fidelity: does the formal theorem say "counts satisfying assignments of every k-CNF in this time," for all inputs, with no hidden hypotheses?
Axioms: print the axioms for the final theorem and confirm only standard ones appear.
Cost model realism: is time measured on a genuine Turing machine with honest input encoding and honest tape access?
Exponent match: does the certified exponent equal the paper's headline exponent?
Scope of the final step: is the inference "subexponential, therefore ETH false" itself formalized or left informal?
Reproducibility: can a stranger rebuild the project and run Comparator?
For more on why checkable outputs matter, see FourfoldAI's analysis of Verifying AI-generated outputs.
The Critical Counterattack: Galactic Constants and Limitations
What Did Dias and Lima Find?
Fabio Dias of the University of Surrey and Yvens Lima of the Universidade Federal do Ceará argue that the OpenAI bounds hide constants so large that they certify no speedup for any input that could physically exist. Their note, arXiv:2611.00517, appeared October 31, 2026. It does not claim the mathematics is wrong. It asks how large n must be before the claimed bounds beat brute force.
The preprint states no constants, so the authors treat the hidden constant C as a parameter. For the general bound, it beats 2^n only beyond roughly n = 10^32 if C = 2, 10^126 if C = 3, and 10^3517 if C = 10.
Then they extract real constants from the tensor-contraction proof. For bounded-density inputs, the certified running time stays above 2^n unless log₂(n+m) exceeds 10^9. On random 3-CNF at the satisfiability threshold, log₂ n must exceed 5 × 10^11.
The Tyranny of Hidden Constants
A "galactic algorithm" is one whose asymptotic win begins only at input sizes no machine could ever store. Commonly cited estimates put the atoms in the observable universe near 10^80. Dias and Lima's figure of 10^3517 dwarfs that.
Read their conclusion carefully. The bounds are subexponential as n goes to infinity, so ETH is still refuted if the proofs hold. But the proof, in their words, certifies no speedup over brute force for any bounded-density input one could write down.
The treewidth result is subtler. For the clause-product form of the interpolation scheme, they prove the cost grows like 2^(Ω(√tw)) at treewidth tw, 2^(Ω(√n)) on random 3-CNF above density 3, and 2^(Ω(n^(1/3))) even on path formulas that are trivial to count. They state that these limits concern that scheme only, and that the preprint's sharper routes escape them.
That caveat is easy to lose in a headline. The critique hits the practical story hard and the theoretical story lightly.
Why CDCL Still Wins
Modern SAT solvers beat any galactic algorithm on real instances because they exploit structure that worst-case analysis ignores. CDCL (conflict-driven clause learning) solvers learn new clauses from failures, use VSIDS-style heuristics to pick branching variables, and rely on watched-literal data structures to propagate cheaply. Industrial instances with millions of variables are often solved quickly, even though worst-case behavior remains exponential.
A subexponential algorithm with a gargantuan leading constant would lose on essentially every formula a human or machine would ever feed it. Anthropic's README itself calls the result purely asymptotic and silent about solving formulas in practice. A public fork of Anthropic's repository is already working on Lean-verified explicit constants, which is the right kind of follow-up.
This is Level 4 of our audit. And at Level 4, the answer today is no.
"ETH Is Dead, Long Live SH": The Theoretical Fallout
What Did the MIT Hardness Group Propose?
The MIT Hardness Group, with Josh Brunner, Erik Demaine and colleagues, argues that ETH is false but Stearns and Hunt's 1990 Satisfiability Hypothesis (SH) remains plausible and can replace it. Their paper, arXiv:2611.02650, was submitted November 2, 2026, and runs 13 pages. They prove SH is equivalent to Weak ETH, which rules out O(2^(n^(1−ε)))·L^O(1)-time 3-SAT algorithms for every ε > 0, where L is input length.
They also show the usual lower-bound recipe survives. If a polynomial-time reduction maps a size-s 3-SAT formula to an instance of size N ≤ s^(b+o(1)), SH rules out O(2^(N^(1/b−ε))) algorithms. ETH would have ruled out 2^(o(N^(1/b))). The counting analogues, #SH and Weak #ETH, rule out O(2^((n+m)^(1−ε))) algorithms for #2SAT.
Fallback Foundations
The practical effect of the fallback is weaker, slightly looser lower bounds: "no 2^(N^(1/b − ε))" instead of "no 2^(o(N^(1/b)))." The lower bounds keep their shape and lose a little tightness. The hardness group's contribution is showing that the standard reduction machinery still works under the weaker assumption.
Which Lower Bounds Survive?
Lower bounds proved by linear-size reductions from 3-SAT keep a version of their strength under SH. Many exact-exponential and parameterized results can be restated this way.
SETH is a harder question. By the sparsification argument, a 2^(o(n)) algorithm for every fixed k appears incompatible with the standard k-SAT form of SETH. That is our own reading of the standard implications. We did not find the reviewers or the MIT abstract addressing it directly, so treat it as open. If it holds, the fine-grained quadratic-time bounds for Edit Distance, Longest Common Subsequence, Fréchet Distance and Orthogonal Vectors would need a firmer footing, possibly via a stronger formulation of SETH for unrestricted CNF-SAT. Expect that debate in the coming months.
Real-World Computing, Enterprise AI and Research Practice
Industrial SAT solving, logistics optimization and hardware verification will not change because of this result. Real chip-verification and planning workloads run on CDCL solvers tuned for structure, and the new algorithms carry constants that make them unusable. For engineering teams, the immediate takeaway is to keep doing what they are doing.
The research story is different. Two frontier labs report AI-powered mathematical research that produced an algorithm experts did not expect, plus a machine-checkable proof, within days. That is a new working pattern: model proposes, kernel checks, humans audit the statement. It echoes themes in FourfoldAI's coverage of AI reasoning capabilities and of Autonomous AI research systems.
Leaders deciding how to use such tools should note the compute and review costs. Fourteen million output tokens for one discovery run is a data point, and the human audit time dwarfs it. See our guide to Computing requirements for AI research for planning.
Three takeaways for research and engineering leaders:
Demand the four-level audit before repeating any "AI proved X" headline internally.
Fund statement review, not just proof checking. The scarce resource is a human who can read a formal specification.
Treat asymptotic results as theory until someone shows a constant you could run.
Frequently Asked Questions
What is the Exponential Time Hypothesis (ETH)?
ETH is a 1999 conjecture by Impagliazzo and Paturi that 3-SAT cannot be solved in subexponential time. Formally, some constant ε > 0 exists such that no algorithm decides n-variable 3-SAT in 2^(εn) time. Hundreds of conditional lower bounds in graph algorithms and parameterized complexity depend on it. ETH implies P ≠ NP, but not the other way around.
Did OpenAI disprove the Exponential Time Hypothesis?
OpenAI claims it did, but the claim is not yet peer-reviewed. Its preprint describes a deterministic counting algorithm running in 2^(O(n·loglog n/√log n)) time. Lean certifies a slightly weaker exponent, which still refutes ETH. Impagliazzo, Paturi and Williams are leading a review. Treat it as a strong, machine-checked, still-pending claim.
Did Anthropic independently disprove ETH?
Anthropic claims an independent refutation, found by an internal Claude model on October 16. Its paper presents a deterministic algorithm that counts 3-SAT solutions in 2^(O(n·loglog n/√log n)) time, with a Lean 4 formalization checked by a second kernel. Both papers cite each other as concurrent. Independent human audit of the formal statement is still outstanding.
Does disproving ETH mean that P equals NP?
No. A subexponential algorithm is still superpolynomial, so refuting ETH says nothing about whether P equals NP. Running times like 2^(n/√log n) grow faster than any polynomial. Fortnow also notes that subexponential algorithms for all of NP would need a far stronger 3-SAT bound than either lab achieved. The P versus NP question remains open.
What is the difference between 3-SAT and #3-SAT?
3-SAT asks whether any assignment satisfies a formula; #3-SAT asks how many assignments do. Counting is at least as hard as deciding and is #P-complete. If you can count solutions, you can decide satisfiability by checking whether the count is nonzero. That is why both labs emphasize their counting algorithms: the claim is stronger.
What is Lean 4 and can its formal verification fail?
Lean 4 is a proof assistant whose small trusted kernel checks every step of a formal proof. The kernel can be trusted, but the statement being proved might not match the real claim, through flawed definitions or a mismatched cost model. Anthropic's repository notes that no machine checks that its Lean file says what the paper says.
What is a "galactic algorithm" in the context of the ETH proof?
A galactic algorithm has a better asymptotic running time but wins only on inputs too large to exist. Dias and Lima report that OpenAI's bounds beat brute force only past n of about 10^32 to 10^3517, depending on the hidden constant. For the extracted constants, log₂(n+m) must exceed 10^9 for bounded density. No physical input qualifies.
What is the Satisfiability Hypothesis (SH)?
SH is Stearns and Hunt's 1990 hypothesis, shown equivalent to Weak ETH, that 3-SAT has no O(2^(n^(1−ε)))·poly-time algorithm. The MIT Hardness Group's November 2026 paper argues it remains plausible after ETH's refutation and that it preserves the standard lower-bound reduction technique, with slightly looser exponents than ETH gave.
Limitations of Current Knowledge
No outside expert has publicly certified either proof as correct. The Lean evidence for OpenAI covers a weaker exponent than the headline, and the statement-fidelity check for both labs relies on human reading. Our own read of the papers is partial, and the SETH consequences are our inference, not a published result. Figures from Dias and Lima come from a preprint that has not been peer-reviewed either.
Conclusion: Is ETH Truly Dead?
ETH is, at best, badly wounded: two machine-checked, AI-found algorithms make a subexponential 3-SAT algorithm look real, but formal fidelity, expert review and practical relevance are three separate questions, and only the first has strong evidence. At Level 1, the claims exist. At Level 2, the Lean files build and use standard axioms. At Level 3, OpenAI's gap is documented and Anthropic's needs audit. At Level 4, nothing runs faster than the solver on your server.
The larger story is the workflow. A model proposes an argument no human expected, a kernel checks it, and the field's founders organize the human audit. If that pattern holds, theoretical computer science just gained a very fast collaborator and a new bottleneck: people who can read specifications.
Want more clear-eyed reporting on AI research claims, from formal proofs to agentic systems? Explore more guides at fourfoldai.com.
References
This article is backed by authoritative sources and primary research documents.
OpenAI, The Exponential Time Hypothesis is False (preprint, repository version dated October 25, 2026): https://github.com/openai/math/blob/main/preprints/The-Exponential-Time-Hypothesis-is-False-October-25-2026/paper.pdf
Anthropic (Claude), A 2^o(n) Time Algorithm for 3-SAT (paper dated October 26, 2026, with Lean 4 formalization and README): https://github.com/anthropics/formal-math/blob/main/eth/README.md
Fabio Dias and Yvens Lima, Limits and Constants of OpenAI's Claimed ETH Refutation, arXiv:2611.00517 (October 31, 2026): https://arxiv.org/abs/2611.00517
MIT Hardness Group et al., ETH is Dead, Long Live SH, arXiv:2611.02650 (November 2, 2026): https://arxiv.org/abs/2611.02650
Lance Fortnow and Bill Gasarch, "The Exponential Time Refutation," Computational Complexity blog (October 28, 2026): https://blog.computationalcomplexity.org/2026/10/the-exponential-time-refutation.html
John D. Cook, "The Exponential Time Hypothesis is False" (October 27, 2026): https://www.johndcook.com/blog/2026/10/27/eth-false/
Wikipedia, "Exponential time hypothesis" (includes dated coverage summaries): https://en.wikipedia.org/wiki/Exponential_time_hypothesis
Dataconomy, "OpenAI and Anthropic claim AI disproved the exponential time hypothesis" (November 4, 2026): https://dataconomy.com/2026/11/04/openai-and-anthropic-claim-ai-disproved-the-exponential/
WebProNews, "Two AI Labs Claim the Exponential Time Hypothesis Is False": https://www.webpronews.com/openai-anthropic-exponential-time-hypothesis-refuted-sat/
Community reproduction of OpenAI's Lean build (AI-assisted, not an endorsement): https://github.com/unaltuzun/exponential-time-hypothesis-verify
Kingy.ai, OpenAI ETH claim tracker (Lean scope 378 summary): https://kingy.ai/mathematics-science-breakthrough-tracker/records/cs-exponential-time-hypothesis-refutation-openai-2026/
Lean Community, Theorem Proving in Lean 4: https://lean-lang.org/theorem_proving_in_lean4/
Russell Impagliazzo and Ramamohan Paturi, "The Complexity of k-SAT," IEEE CCC 1999: https://doi.org/10.1109/CCC.1999.766282
Russell Impagliazzo, Ramamohan Paturi and Francis Zane, "Which problems have strongly exponential complexity?" JCSS 2001: https://doi.org/10.1006/jcss.2001.1774
Disclaimer
This article is for informational and educational purposes only. It reports claims that were under active expert review at the time of writing and does not constitute professional, technical or investment advice. For the full disclaimer, visit fourfoldai.com/disclaimer.
About the Author
Muizz Shaikh is an AI enthusiast and digital technology professional at FourfoldAI. He is passionate about exploring AI tools, industry trends, and practical applications of emerging technologies. Through FourfoldAI, Muizz contributes to simplifying artificial intelligence for businesses and learners. Connect with him on LinkedIn: linkedin.com/in/muizz-shaikh-45b449403/
© 2026 FourfoldAI. All rights reserved.




Comments