What Changed in 2024-2025 That Made Agentic AI Real
For years, people talked about autonomous agents as a future capability—something that would arrive eventually. Then two things happened in close succession that actually made it viable.
First, the LLMs themselves got better at reasoning. By mid-2024, Claude 3, GPT-4 Turbo, and emerging open models showed consistent improvement in chain-of-thought reasoning, instruction following, and error correction. They could maintain context better, handle longer documents without losing coherence, and most importantly—they could admit uncertainty rather than confidently hallucinating.
Second, function calling matured. OpenAI’s function calling in GPT-4, Claude’s tool_use in the 3.5 and 4 families, and the parallel evolution of standards like the Model Context Protocol (MCP) meant that the friction of connecting AI to external systems dropped dramatically. An agent could now ask for data from a database, invoke a Python script, call a search API, or trigger a lab instrument with the same syntax it used to write text. That uniformity unlocked something: real composition. Real automation.
The third factor was practical: cost fell and speed improved. Running a 100k-token context window through Claude Opus doesn’t require signing a contract with a venture capitalist anymore. Inference got faster. Latency dropped from seconds to subseconds for simpler tasks. That made iteration possible, which made agentic workflows viable.
And then the frameworks appeared. LangChain, AutoGen, CrewAI, and others went from experimental toy code to actually usable abstractions that let founders and researchers build on top of stable APIs. The infrastructure matured.
So by late 2025, agentic AI wasn’t a theoretical capability—it was something you could build on a Tuesday afternoon with a competent engineer and an API key. That’s why you’re seeing it now in biotech labs, research institutions, and startups building the next wave of scientific tooling.
What Agentic AI Actually Means (vs. Chatbots, vs. Copilots)
Before I explain how agentic systems work, let me be precise about what distinguishes them from the things that came before.
A chatbot is stateless stimulus-response. You ask it a question, it generates an answer, the interaction ends. GPT-3.5 in a web interface is a chatbot. Impressive, useful, but fundamentally reactive and bounded by a single turn of conversation.
A copilot is a chatbot that’s aware of context—it knows about your document, your codebase, your recent files—and it can suggest actions or completions based on that context. GitHub Copilot is a copilot. It improves on a chatbot because it has sight lines into your actual work, but it still requires a human to evaluate each suggestion and decide whether to accept it. The human is the autonomous agent; the AI is the oracle.
An agentic AI system is different in kind, not just degree. It has a goal, a mental model of the world (however crude), the ability to choose between multiple tools to solve a problem, feedback loops that let it know whether its actions worked, and crucially—permission and capability to execute actions autonomously. You don’t have to approve each step. You set the system loose with constraints and objectives, and it figures out how to reach them.
The distinction matters operationally. With a chatbot, every output needs human validation. With a copilot, you’re validating suggestions. With an agentic system, you’re checking results—which is far less cognitively expensive and scales to problems that are too granular for human-in-the-loop workflows.
I should be clear: “autonomous” doesn’t mean unsupervised. The best agentic systems in production right now are operating within guardrails. They can’t make irreversible decisions without approval. They can’t spend money without authorization. But within their sandbox, they’re genuinely autonomous. They can retry failed steps, branch into sub-problems, allocate computational resources across subtasks, and learn from what went wrong.
The practical implication is this: if you’re building research infrastructure in 2026, you’re either building with agentic systems or you’re accepting that your workflows will be less efficient than they could be. That’s not hype. That’s just reality.
How Agentic AI Works: The Core Architecture
Building an agentic system requires solving five problems in sequence. Most frameworks you’ll encounter in 2026 are really implementations of how to solve these five problems well.
The Perception Problem: Context and Reasoning
An agentic system starts by understanding what it’s trying to do. This isn’t just prompt engineering—it’s about giving the system the right conceptual frame to reason about the problem. In practice, this usually means a detailed system prompt that explains the role (“you are an AI research assistant”), the constraints (“you cannot delete files”), and the objective (“synthesize a summary of CRISPR resistance mechanisms from the attached papers”).
The LLM then needs to understand the current state of the world. What data is available? What’s already been done? What’s failed in the past? This is where the “context window” matters. Modern LLMs like Claude Opus can handle 100k-200k tokens of context, which means you can include entire papers, code repositories, or experimental logs as input. The agent can literally read your lab notebook and reason about what comes next.
But here’s where most people get it wrong: you can’t just dump a 200k-token context and hope it reasons correctly. The best agentic systems in production use a technique called chain-of-thought reasoning where the model is explicitly asked to show its work. Instead of jumping to an answer, it writes something like: “To synthesize the literature on CRISPR resistance, I should (1) list all papers mentioned, (2) identify the three major mechanisms, (3) find the most recent evidence for each, (4) note limitations and open questions.” That metacognitive step—talking itself through the problem—improves the quality of the subsequent actions dramatically.
The Planning Problem: Breaking Work Into Steps
An agentic system needs to convert a high-level goal into a sequence of executable steps. This is usually called planning, and it’s harder than it sounds because the agent can’t know in advance exactly how many steps it’ll need or what each step should be.
The most effective approach in 2025-2026 is called ReAct (Reasoning + Acting), which is exactly what it sounds like: the agent thinks through what it needs to do, then it acts, then it observes the result, then it thinks again. This loop repeats until the goal is achieved or the system hits a boundary condition.
In practice, this might look like: the agent decides it needs to search the literature, it executes a search query, it gets back ten papers, it observes that some are relevant and some aren’t, it refines its strategy, it searches again. That iterative tightening is what makes agentic systems smarter than one-shot LLM calls. They’re not trying to get it right the first time; they’re trying to iterate toward correctness.
The Tool Use Problem: Function Calling and Integration
Here’s the non-obvious part of agentic systems: they’re only as useful as the tools they can access. An agentic system that can only read text is interesting. An agentic system that can read text, call APIs, execute code, query databases, and trigger hardware is genuinely transformative.
This is where function calling becomes critical. Instead of the LLM generating text that says “I would now call this API endpoint,” it actually calls the endpoint and gets back a result it can reason about. The syntax looks something like: the model generates a JSON blob that says {“function”: “search_pubmed”, “params”: {“query”: “CRISPR resistance”, “limit”: 10}}, the system parses that, executes the search, and hands the results back to the model as structured data. The model can then reason about what it got.
The Model Context Protocol (MCP) is emerging as the standard way to integrate tools. Instead of each LLM provider defining their own tool syntax, MCP proposes a common interface: tools expose capabilities, the system can introspect those capabilities, and the model can use them via a standard calling convention. That matters because it means an agentic system can be tool-agnostic. You can hand it access to a local compute cluster, a cloud API, a scientific database, and a lab automation system, all via the same interface.
In my own work, I’ve found that the quality of the available tooling directly determines whether an agentic system succeeds or fails. If your agent has access to domain-specific functions (like “predict this protein structure” or “simulate this molecular interaction”), it becomes genuinely competent. If it’s limited to generic tools (web search, code execution), it stays novice.
The Memory Problem: Keeping Track of What’s Happened
A system that reasons step-by-step but forgets everything after each step isn’t really an agent—it’s just an expensive way to run repeated LLM calls. Real agentic systems need memory.
There are three layers of memory that matter in production systems. Short-term memory is the context window itself—everything the model is currently thinking about. This is bounded and it resets between sessions, so it’s useful for immediate problem-solving but not for learning across days or weeks.
Long-term memory usually means a vector database or similar retrieval system where you store information about past actions, past results, and learned patterns. If an agent solved a similar problem last week, you want it to be able to retrieve that solution and adapt it. The way this usually works is: after the agent finishes a task, a summary is extracted and stored with metadata (what was the problem, what was the approach, what worked and what didn’t). On the next run, if the agent encounters a similar problem, you perform a semantic search over those summaries, and you can inject relevant historical context into the prompt.
External memory is everything outside the model itself: logs, databases, file systems, prior conversations. The trick is knowing when to query external memory and how to integrate the results. An agent that queries its database on every step will be slow and expensive. An agent that never checks external sources will be blind. The best systems use a form of selective querying: they check external memory for specific high-value questions (does this exact problem already have a known solution?), and they reason mostly over information they’ve already internalized.
The Action Execution Problem: Actually Making Things Happen
This is the point at which an agentic system stops being theoretical and becomes operationally real. The model generates an action, the system executes that action, and the world changes. This is where most of the safety and reliability constraints come in.
In a well-designed agentic system, not all actions are equally privileged. Reading data should be cheap and fast. Modifying data should require slightly more scrutiny—maybe a flag that says “confirm this change.” Deleting data or executing irreversible operations should require explicit human authorization. Running a compute job might need cost approval. Accessing restricted databases might need credential management.
The execution layer needs to handle errors gracefully. If an action fails (the API is down, the tool crashes, the function returns an unexpected result), the agent needs to see that failure as information, not as terminal. A mature agentic system will retry failed operations with backoff, try alternative approaches, or escalate to a human if it’s stuck.
In biotech specifically, this means something else: the system needs to be able to handle the reality that experiments fail, measurements are noisy, and results are often incomplete or ambiguous. An agent that was trained on text might assume that every function call returns clean data. But a real biotech agent needs to handle missing data points, sensor errors, reagent failures, and the general chaos of actual lab work.
The Major Agentic Frameworks in 2026
If you’re starting to build an agentic system, you’ll almost certainly build on top of one of these frameworks. They’ve matured significantly since 2024, and they’re all production-viable.
LangChain remains the most widely adopted framework for building agentic systems. It provides abstractions over memory, tool use, planning, and execution. Its ReAct agent is the reference implementation that most other frameworks copied. The strength of LangChain is comprehensiveness—it handles almost every pattern you’ll encounter. The weakness is that it can feel overengineered if you’re building something simple. It’s also been in a constant state of API churn, which has burned some users. But if you’re using it in 2026, the API has stabilized considerably compared to 2023-2024.
AutoGen, built by Microsoft, takes a different approach. Instead of a single agent, AutoGen models multi-agent conversations where specialized agents communicate with each other to solve problems. You might have a researcher agent, a coding agent, and an executor agent, and they coordinate through natural language conversation. This is philosophically appealing and works well for problems that naturally decompose into specialized roles. The main limitation is that it’s heavier-weight than single-agent frameworks—it’s designed for complex multi-step research problems, not for simple automation.
CrewAI is designed explicitly for multi-agent systems and emphasizes the idea of crews (coordinated teams of agents) working on shared missions. It’s similar in philosophy to AutoGen but with a different API and slightly different strengths. If you’re building a system where multiple specialized agents need to coordinate, CrewAI is worth evaluating.
Claude Code and the Model Context Protocol represents a different philosophy: instead of a separate framework, the protocol is embedded directly into the Claude API. When you use Claude with MCP-compliant tools, you’re building agentic systems without needing a separate orchestration layer. This is elegant and reduces architectural complexity. The tradeoff is that you’re constrained to Claude, which is fine if Claude is your model of choice, but it limits flexibility if you want to run multiple models.
OpenAI Agents SDK is the newest entrant, released as OpenAI’s official agentic framework for GPT-4o and o3. It’s still finding its shape as of early 2026, but it’s clear that OpenAI is positioning agents as a core capability rather than a nice-to-have feature. If you’re deeply integrated with OpenAI’s ecosystem (which many startups are), this will become the natural choice.
Llama Index (formerly GPT Index) focused initially on retrieval but has expanded into agentic workflows. It’s particularly strong if you’re building systems around long-form documents, papers, or knowledge bases. Its query engine can operate agentic-ally, routing queries to different tools based on content.
In practice, the framework you choose matters less than you’d think. Most of them abstract over the same underlying patterns (plan, perceive, act, integrate results). The real differences are in API style, documentation quality, and how well they support your specific use case. If you’re doing biotech research, you might lean toward LangChain (more mature, more examples) or Claude Code (simpler, lower friction). If you’re building a multi-team research operation, AutoGen or CrewAI might make more sense.
My advice: if you don’t have a strong opinion, start with LangChain or Claude Code. Both are mature enough that you won’t hit fundamental limitations, and both have enough examples online that you can get unstuck. Avoid building your own orchestration layer unless you have a very specific need that existing frameworks don’t address.
Agentic AI in Biotech and Research
This is where agentic systems stop being interesting academic exercises and become genuinely valuable. The examples are getting quite concrete as of 2026.
Literature Review at Scale: One of the most immediate use cases is automated synthesis of scientific literature. Biotech companies right now are using agentic systems to read 100+ papers on a specific topic (say, CRISPR off-target effects) and produce a structured summary that answers specific questions: What are the three main mechanisms? What’s the state of the art? What are unresolved problems? What reagents or assays would let us test this?
The agent starts with a search query, retrieves papers, reads them in parallel (because you can chunk the work), extracts relevant facts with semantic matching, cross-references findings across papers, and then synthesizes a report. This used to require a human research scientist spending three weeks on literature review. Now an agentic system can do a first pass in 2-3 hours, and the scientist spends a few hours validating and filling in gaps. That’s a 5-10x efficiency gain for one of the most time-consuming parts of early research.
Experiment Design and Hypothesis Generation: A more ambitious use case is using agentic systems to propose experiments. You feed the system your current understanding (we know X about this protein, we don’t know Y, here’s what we’ve already tried), and the system generates a ranked list of experiments that could resolve the unknowns. This is different from literature review because it requires reasoning about experimental design, not just synthesis. And it requires access to tools: protein structure prediction, assay simulation, reagent availability checkers, cost estimators.
Some labs are building agentic systems that not only propose experiments but also draft the actual protocols (media recipes, incubation times, detection methods) and even order reagents. The human still reviews and approves, but the agent has done 80% of the grunt work that used to be pure busywork.
Drug Discovery Pipelines: The more ambitious deployment I’ve seen is in early drug discovery where agentic systems are integrated into the screening and hit-to-lead process. An agent might start with a target, search for known inhibitors, run virtual screening on large compound libraries, identify promising hits, predict ADMET properties, and flag issues (hepatotoxicity risk, clearance issues, solubility problems) before a chemist even synthesizes anything. Again, this isn’t replacing the chemist—it’s doing the work that used to require running multiple separate tools and then manually integrating the results.
Lab Automation Orchestration: Another emerging pattern is agentic systems controlling actual laboratory hardware—robots, liquid handlers, mass spectrometers, sequencers. The agent receives a task (run this assay on these samples), it decomposes the task (prepare plates, load samples, configure instrument, trigger run, retrieve data), it coordinates with multiple instruments, handles errors (tip rack empty? resupply), and delivers results. This requires integration with both domain expertise (what does a valid assay look like?) and hardware control (can this robot actually do that?).
The constraint here is safety and validation. You can’t have an agent making autonomous decisions about what reagent to use if that decision could compromise an experiment. So the systems that work best have strong domain constraints: the agent can execute from a pre-approved playbook, but it can’t invent new protocols.
Data Analysis and Interpretation: Once you have experimental data (images, chromatograms, sequences, measurements), an agentic system can process that data, flag anomalies, compare to controls, and draft interpretations. This is particularly valuable for high-throughput work where you have thousands of data points and no human can possibly review each one individually. An agent can filter the signal from the noise and present the scientist with: here are the top 20 most interesting results, here’s why they’re interesting, here’s what I’d recommend looking at next.
What excites me about these applications is that they’re not science fiction anymore. They’re not even cutting-edge. Labs are shipping these systems now, and they’re working. The agents aren’t perfect (they still miss things, they still get confused, they still need supervision), but they’re competent enough that they’re delivering value every single day.
Where Agentic AI Fails (Current Limitations)
I want to be honest about the failure modes because they matter for deciding whether agentic systems are appropriate for your use case.
Hallucination and Confabulation: The underlying LLM can still generate false information with confidence. An agent might report that a paper says something it doesn’t actually say, or it might invent a reagent supplier that doesn’t exist. This is less of a problem with modern models (Claude, GPT-4o, and recent open models hallucinate less than earlier versions), but it hasn’t been solved. The mitigation in production systems is almost always: the agent proposes, a human disposes. You check its work.
Tool Errors and Cascading Failures: If an agent has a tools that return bad data, the agent can reason itself into a corner based on that bad data. If you ask an agent to search your database and the database is misconfigured and returns garbage, the agent might dutifully process the garbage and produce confident-sounding wrong answers. The system needs error-checking built in, which usually means re-querying controversial claims or cross-referencing across multiple tools.
Cost: Running an agentic system can be surprisingly expensive, especially if the agent is iterating, retrying, and exploring multiple paths. An agent that makes ten function calls and then rethinks the problem and makes ten more calls has just burned through 20k tokens. If you’re paying for tokens, that adds up. This pushes toward frameworks and model choices that optimize for cost, which sometimes means choosing a cheaper/faster model even if it’s slightly less capable. There’s a real operational constraint here.
Lack of True Uncertainty Quantification: An agentic system might propose an approach, execute it, get back a result, and declare success. But did it actually solve the problem? How confident should you be in the result? Modern systems are better at expressing uncertainty than they were in 2023, but they’re still not great at it. This is why human oversight is essential.
Limited Ability to Handle Ambiguous or Ill-Defined Problems: Agentic systems thrive on problems with clear success criteria and available tools. They struggle with open-ended exploration or problems where the goal itself is fuzzy. If you ask an agent “figure out how to improve our hit-to-lead process,” it won’t know where to start. But if you ask “given these 47 compounds and this ADMET data, identify the three most promising candidates,” it can do that very well.
Supervision Overhead: This deserves its own section because it’s often overlooked. Running an agentic system unsupervised is dangerous (it can make expensive mistakes, it can optimize for the wrong thing, it can get stuck in loops). So most production systems have humans in the loop reviewing decisions. That overhead—the cost of having a human check the agent’s work—can be substantial. In some cases, you’re not actually saving labor; you’re just distributing the labor across the agent and the human in a way that’s less efficient than having the human do it directly. The sweet spot for agentic systems is: tasks that are high-volume but low-risk-per-instance (literature review, data processing, hypothesis generation) where a human can spot-check rather than validate every action.
The honest assessment is this: agentic systems are genuinely useful in 2026, but they’re not autonomous in the sense of needing zero supervision. They’re more like semi-autonomous collaborators. You set them loose, they do the work, you validate the results. If that model works for your use case, agentic systems are transformative. If you need true black-box automation with no human involvement, you’re not ready yet.
What to Actually Build With It in 2026
Given all of this, what should a founder or research team actually be building?
Start with high-volume, low-risk, information-processing tasks. Literature synthesis is the canonical example. Your team is drowning in papers? Build an agentic system to read them and summarize them. The cost is low, the risk is zero (a bad summary isn’t fatal, you’ll catch it in review), and the time savings are real.
Next: data processing and analysis pipelines. If you’re running a high-throughput experiment and generating lots of data, build an agent to process, filter, and flag interesting results. This is valuable specifically because it offloads the boring work (checking that controls look reasonable, flagging obvious outliers, comparing to historical data) that a human would otherwise have to do.
Third: hypothesis and experiment generation. This is slightly higher risk because a bad hypothesis can lead to wasted resources. But it’s still valuable if it’s advisory (the agent proposes experiments, you decide which to actually run). The time savings here come from not having to manually search the literature and design controls for each hypothesis—the agent does that scaffolding work.
Be cautious about: autonomous decision-making in consequential domains. Don’t build an agent that autonomously decides what compounds to synthesize or what patients to enroll in a study without explicit human approval. Don’t build an agent that autonomously orders reagents with corporate credit cards. The risk-to-automation tradeoff doesn’t work yet.
And don’t build your own orchestration layer unless you have to. The frameworks exist. Use them. You want to focus on domain expertise and data integration, not on reinventing the planning and memory components.
What’s Coming: The Roadmap
Where is this heading by 2027-2028?
The models themselves will keep improving at reasoning. We’re seeing this already with o1 and similar reasoning-focused architectures. That means agents will be able to handle more complex multi-step problems without getting lost. They’ll be less likely to hallucinate. They’ll be better at debugging their own work.
Tool integration will become seamless. Right now, connecting an agent to a new tool requires some engineering work. By 2027, it’ll be closer to configuration. You’ll describe what a tool does in natural language, and the framework will automatically expose it to the agent. That lowers the friction for non-engineers to build agentic systems.
Multi-agent systems will mature. Right now, most deployed agents are single-purpose specialists. By 2027, we’ll see more sophisticated multi-agent architectures where teams of agents coordinate on complex problems. You might have a researcher agent, a statistician agent, and an ethics agent working together on a drug discovery task.
Cost will continue to fall. Inference is getting cheaper. Models are getting faster. Frameworks are getting more efficient. That means agentic systems that are marginally economical today will become obviously worth it.
And most importantly: we’ll see better integration with domain expertise. Right now, agentic systems are generic—they work for any problem if you give them the right tools. But domain-specific agents (agents trained on biotech knowledge, agents optimized for molecule design, agents that understand lab protocols) will become possible and valuable.
The inflection point will be when building an agentic system for your specific use case is faster and cheaper than building a traditional software application. I think we’re within 12-18 months of that inflection.
Conclusion
Agentic AI is not the future. It’s the present, and if you’re building research infrastructure or knowledge work in 2026, you’re behind if you’re not at least experimenting with it.
The systems available right now are not perfect. They hallucinate, they fail, they need supervision. But they’re good enough that they deliver genuine value on real problems. Literature review, data synthesis, experiment design, hypothesis generation—these are being automated right now, and the teams using those systems are getting through research faster than teams that aren’t.
If you want to stay ahead of where AI and longevity are actually going, subscribe to Accelerated — my weekly newsletter on the frontier of biotech and AI. Subscribe here