AI Patent Drafting, Intelligent Agents, and Claim Differentiation: Lessons from Applications in Internet Time v. Salesforce

PatentNext Takeaway: In Applications in Internet Time, LLC v. Salesforce, Inc., the Federal Circuit provided a useful reminder for drafting AI-related patent claims: dependent claims can help preserve broader independent-claim scope where the dependent claims separately recite narrower AI or agent-based implementations.

Although Applications in Internet Time was not a generative AI case, its reasoning is directly relevant to modern AI patent practice. The disputed claim language concerned “automatically detecting” changes, while a dependent claim separately recited “one or more intelligent agents” that performed that detection. The Federal Circuit held that claim differentiation provided a strong reason not to read the “intelligent agents” limitation into the broader independent claim.

For AI patent practitioners, the lesson is practical. When drafting or amending claims directed to AI systems, machine-learning workflows, autonomous agents, model-based processing, or AI-assisted automation, dependent claims should not be treated merely as fallback positions. They can also help preserve the distinction between a broad AI-enabled function and a narrower implementation of that function.

That strategy has limits. As cases such as Cave Consulting Group, LLC v. OptumInsight, Inc. show, later-added dependent claims cannot overcome a specification that consistently and affirmatively limits the invention to a narrower implementation. Thus, dependent claims can support claim differentiation only where the specification already supports the broader claim scope. 

Thus, the best practice is to draft both the specification and the claim set to support a deliberate hierarchy: broader AI functionality in the independent claims, and narrower model-, agent-, data-, or architecture-specific implementations in dependent claims.

****

Background: AI Claims Often Turn on the Level of Implementation Detail (Using Dependent Claims as More Than Fallback Positions)

AI patent claims frequently raise a familiar drafting problem: how much implementation detail should be included in the independent claim?

On one hand, claims that merely recite a desired AI result—such as “classifying data,” “generating a recommendation,” “detecting an anomaly,” or “automatically determining an output”—may face scrutiny under § 101, § 103, or § 112. Examiners may ask whether the claim recites a technological improvement, whether the claimed functionality is conventional, or whether the specification sufficiently describes how the AI functionality is actually performed.

On the other hand, overloading the independent claim with too much implementation detail can unnecessarily narrow the claim. For example, an independent claim that requires a particular type of model, a particular neural-network architecture, a particular training technique, or a particular agent-based workflow may be easier to distinguish during prosecution, but may also be easier for competitors to design around.

This is where dependent claims can play an important role.

A well-drafted AI claim set can separate the broader AI-enabled functionality from specific implementations. The independent claim may recite the broader technical operation, while dependent claims recite narrower embodiments such as:

• a neural network;
• a transformer-based model;
• a large language model;
• a reinforcement-learning policy;
• a retrieval-augmented generation workflow;
• one or more autonomous software agents;
• a feature-extraction pipeline;
• a vector database;
• a prompt template;
• a model-training workflow;
• a post-processing rule set; or
• a safety, validation, or guardrail process.

That structure can provide fallback positions. But it can also do something more: it can help show that the independent claim is not limited to the narrower implementation recited in the dependent claim.

The Prosecution Problem: Amendments Can Narrow Claims More Than Intended; but Claim-Differentiation can help redefine Scope

Software and AI-related patent applications often face multiple forms of scrutiny during examination. An examiner may reject the claims under § 101 as allegedly directed to an abstract idea. The examiner may also raise novelty or obviousness rejections under §§ 102 or 103, particularly where the claim recites broad software functionality. And, increasingly, examiners may raise § 112 issues where the claims recite technical functionality without enough supporting detail in the specification. See PatentNext: USPTO Examiners issue more Written Description (Section 112) rejections following Precedential Ex Parte Desjardins decision.

In response, applicants often amend independent claims to provide more technical specificity. That may be necessary and appropriate. For example, an applicant may amend a claim to recite a particular data structure, computer architecture, model-training workflow, communication sequence, or control process.

But such amendments raise a recurring strategic issue: how can the applicant distinguish the prior art or clarify the invention without unintentionally limiting the independent claim to a single implementation?

One answer is to use dependent claims deliberately. When an applicant amends an independent claim, the applicant should consider whether additional dependent claims should be added to capture narrower implementations. These dependent claims may later help demonstrate that the independent claim remains broader than those specific implementations.

For example, consider the following simplified claim set:

1. “A computer-implemented method comprising automatically detecting a change in application data and updating a user interface based on the detected change.”
2. “The method of claim 1, wherein automatically detecting the change comprises using one or more intelligent agents.”

In that example, claim 2 can help support the argument that claim 1 is not limited to intelligent agents. Claim 2 adds that specific implementation. Therefore, reading claim 1 to already require intelligent agents would risk making the dependent claim redundant.

That is the basic claim-differentiation point. 

The doctrine of claim differentiation generally recognizes that different claims are presumed to have different scope. The doctrine is particularly powerful where a dependent claim adds a limitation that an accused infringer later seeks to import into the independent claim.

In practical terms, if independent claim 1 recites “automatically detecting an anomaly,” and dependent claim 2 recites that the detecting is performed “using a trained neural network,” there is a claim-differentiation argument that claim 1 should not be limited to neural-network-based detection.

Likewise, if independent claim 1 recites “generating a response based on input data,” and dependent claim 2 recites that the response is generated “using a transformer-based large language model,” there is an argument that claim 1 should not be construed to require a transformer-based LLM.

Of course, claim differentiation is not absolute. The specification and prosecution history still matter. But when the intrinsic record supports broader scope, dependent claims can become important claim-construction evidence.

That is the lesson illustrated by Applications in Internet Time. 

Applications in Internet Time v. Salesforce: A Recent AI / Software Example

In Applications in Internet Time, LLC v. Salesforce, Inc., the Federal Circuit addressed AI-based software patents directed to dynamically generated applications. Nos. 2024-1133, 2024-1685, 2024 WL 4487251 (Fed. Cir. Oct. 10, 2024) (nonprecedential). The claims involved computer systems including intelligent agents, server computers, client computers, browser applications, application layers, and a “change management layer” for automatically detecting changes that affect an application.

The district court construed “automatically detecting” to require “detecting without human intervention through the use of one or more intelligent agents.” That construction became case-dispositive. Because the accused Salesforce products allegedly did not use intelligent agents in the manner required by the district court’s construction, the district court granted summary judgment of non-infringement.

The Federal Circuit reversed that claim-construction ruling.

The key claim-differentiation issue was straightforward. Independent claim 1 recited a “change management layer for automatically detecting changes that affect an application.” But dependent claim 8 expressly recited that the change management layer comprised “one or more intelligent agents.” The Federal Circuit found that this claim structure provided a strong reason not to import the “intelligent agents” limitation into the independent claim.

That aspect of the decision is useful for software patent practitioners because it shows how a dependent claim can preserve broader independent-claim scope. The independent claim recited the broader software functionality: automatically detecting changes. The dependent claim recited a narrower way to perform that functionality: using intelligent agents. Because the narrower implementation appeared in the dependent claim, the Federal Circuit declined to read that implementation into the independent claim.

The court also rejected the argument that the specification limited the invention to intelligent agents. Although the specification discussed intelligent agents, the Federal Circuit viewed those disclosures as exemplary rather than limiting. The court explained that the repeated use of intelligent agents in the best-mode discussion showed that intelligent agents may be a preferred implementation, not that they were required by the claims.

That distinction is important. In software patents, specifications often describe one implementation in detail. But unless the specification or prosecution history clearly limits the invention to that implementation, the claims should not automatically be confined to it. Dependent claims can reinforce that point by expressly claiming the narrower implementation separately.

That distinction is critical for AI patent practice. 

Why AIT Matters for Software and AI Claim Drafting

The AIT decision is nonprecedential. Even so, it provides a useful and recent illustration of a practical drafting point: dependent claims can help separate broad AI and software functionality from specific implementation details.

That distinction is especially important for modern software and AI inventions. Consider the following examples:

• an independent claim recites “classifying input data,” while a dependent claim recites that the classification uses a neural network;
• an independent claim recites “generating a response using a machine-learning model,” while a dependent claim recites that the model is a transformer-based large language model;
• an independent claim recites “retrieving context data,” while a dependent claim recites retrieval from a vector database;
• an independent claim recites “automatically detecting an anomaly,” while a dependent claim recites detection using a trained anomaly-detection model;
• an independent claim recites “modifying an interface based on user activity,” while a dependent claim recites a specific event-listener or agent-based implementation.

In each example, the dependent claim may help preserve the broader scope of the independent claim. If the specification supports multiple ways to perform the claimed function, dependent claims can make that breadth visible in the claim set.

This can be especially valuable after an amendment. For example, if an applicant amends an independent claim to overcome prior art by reciting “automatically detecting a change in a deployed application,” the applicant may also add dependent claims reciting specific detection mechanisms. Those dependent claims can serve as both fallback positions and claim-differentiation anchors.

The claim set then communicates a hierarchy:

• the independent claim covers the broader technical concept;
• dependent claim 2 covers implementation A;
• dependent claim 3 covers implementation B;
• dependent claim 4 covers implementation C.

That hierarchy may later help rebut an accused infringer’s attempt to limit the independent claim to only one disclosed implementation.

Modern AI applications may involve software agents, autonomous agents, LLM agents, planning agents, monitoring agents, retrieval agents, classification agents, or model-based decision agents. In some applications, the agent is the invention. In others, the agent is one possible implementation of a broader automated process. 

Cave Consulting: The Important Cautionary Example

The usefulness of dependent claims has limits. The Federal Circuit’s decision in Cave Consulting Group, LLC v. OptumInsight, Inc. illustrates the other side of the doctrine. 725 F. App’x 988 (Fed. Cir. 2018). 

In Cave Consulting, the claims related to computer-implemented methods for analyzing physician efficiency using medical claims data. The dispute concerned whether the claimed “weighted episode of care statistics” covered direct standardization or was limited to indirect standardization.

The patentee relied on dependent claims that specifically recited direct standardization. The argument was that, under claim differentiation, the independent claims should be broad enough to cover direct standardization because the dependent claims expressly recited it.

The Federal Circuit disagreed. The problem was the specification. The court concluded that the specification repeatedly and consistently described the invention as using indirect standardization and distinguished that approach from direct standardization used in the prior art. In that context, the later-added dependent claims could not overcome the limiting description in the specification.

That is the key caution: claim differentiation is a tool of claim construction, not a substitute for written-description support. Dependent claims can help preserve broad claim scope only if the specification supports that breadth.

This point is particularly important when dependent claims are added during prosecution. If the original specification describes only one implementation as the invention, and disparages or excludes alternatives, later-added dependent claims may not be enough to broaden the independent claim. Worse, such dependent claims may invite written-description challenges if the specification does not reasonably convey possession of the later-claimed alternative.

Thus, the drafting lesson is twofold:

1. Use dependent claims to preserve meaningful claim-scope distinctions.
2. Draft the specification from the outset to support those distinctions.

Practice Tips for Patent Prosecutors

The practical takeaway is that dependent claims should be drafted with future claim construction in mind. When amending AI and software claims, practitioners should consider the following strategies.

1. Add dependent claims that expressly recite narrower implementations

If the independent claim recites broader functionality, consider dependent claims that recite specific implementations. For example:

• “wherein the detecting is performed using one or more intelligent agents”;
• “wherein the classifying is performed using a trained neural network”;
• “wherein the retrieving comprises querying a vector database”;
• “wherein the generating comprises applying a transformer-based language model”;
• “wherein the updating comprises transmitting a synchronization message using a publish-subscribe protocol.”

These dependent claims may provide fallback positions and help show that the independent claim is not limited to those narrower implementations.

2. Avoid prosecution remarks that collapse the claim hierarchy

Dependent claims are less useful if the applicant’s remarks describe the independent claim as requiring the narrower dependent-claim feature. For example, if claim 1 recites “automatically detecting” and claim 2 recites “using intelligent agents,” the applicant should be careful before arguing that “the claimed invention requires intelligent agents” unless that is truly intended.

A better approach may be to distinguish the independent claim based on its actual amended language, while preserving dependent claims as additional, narrower implementations.

3. Draft the specification to support multiple implementations

Claim differentiation works best when the specification supports the broader genus. For software and AI inventions, the specification should identify alternative implementations where possible.

For example, if an invention involves automatic detection, the specification might describe detection using rules, event listeners, intelligent agents, machine-learning models, polling, message queues, or other mechanisms. If an invention involves classification, the specification might describe neural networks, decision trees, support vector machines, rules-based classifiers, or other models.

The goal is not to list alternatives without substance. The goal is to provide enough technical detail to show possession of the broader concept and its representative implementations.

4. Be careful with “the invention” language

Courts may treat repeated descriptions of “the invention” as limiting in some circumstances, particularly where the specification consistently characterizes the invention as requiring a particular feature. Patent drafters should therefore use care when describing embodiments.

Rather than stating that “the invention uses an intelligent agent,” it may be preferable to state that “in some embodiments, the system uses an intelligent agent,” or that “the automatic detection may be performed using one or more intelligent agents, event listeners, polling routines, rules-based engines, machine-learning models, or other detection mechanisms.”

That type of drafting can preserve flexibility and support later claim-differentiation arguments.

5. Use dependent claims to create a deliberate claim hierarchy

A strong software claim set often has a layered structure:

• an independent claim directed to the broader architecture or technical process;
• dependent claims directed to particular implementation mechanisms;
• dependent claims directed to data structures, model types, communication protocols, user-interface behavior, or deployment environments;
• dependent claims directed to performance improvements or technical effects.

This hierarchy can be valuable during prosecution, during continuation practice, and later during claim construction.

Conclusion: Dependent Claims as Claim-Construction Assets

Dependent claims should not be treated as an afterthought. In AI, software, and computing patents, they can be especially valuable because software inventions are often implemented in multiple ways. A claim set that captures those implementation differences can preserve flexibility during prosecution and provide important claim-construction support later.

Applications in Internet Time v. Salesforce illustrates the upside. A dependent claim reciting “intelligent agents” helped prevent that limitation from being imported into broader independent claims directed to automatic detection.

Cave Consulting illustrates the caution. Dependent claims cannot expand claim scope beyond what the specification supports, particularly where the specification consistently limits the invention to a narrower implementation.

The best practice is therefore clear: when amending software claims, practitioners should not only ask what language will overcome the rejection. They should also ask what dependent claims are needed to preserve the intended claim hierarchy.

In other words, dependent claims are not merely backup claims. Properly drafted, they can be claim-construction assets.

****

Subscribe to get updates to this post or to receive future posts from PatentNext. Start a discussion or reach out to the author, Ryan Phelan, at rphelan@marshallip.com or 312-474-6607. Connect with or follow Ryan on LinkedIn.