🤖 AI

IdeaForge: A Knowledge Graph-Grounded Multi-Agent Framework for Cross-Methodology Innovation Analysis and Patent Claim Generation

This paper presents IdeaForge, a knowledge graph-grounded multi-agent framework that integrates TRIZ, Design Thinking, and SCAMPER methodologies to synthesize cross-methodological insights, identify high-confidence innovations through graph-based claim convergence, and generate traceable patent drafts.

Original authors: Joy Bose

Published 2026-05-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Joy Bose

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to invent something new, like a new type of smartphone or a better way to organize a library. Usually, inventors use one specific "recipe" or method to come up with ideas. They might use a method called TRIZ (which looks for technical contradictions), Design Thinking (which focuses on what users need), or SCAMPER (which looks at how to twist and change existing things).

The problem, according to this paper, is that most AI systems today only use one recipe at a time. They cook a meal, serve it, and then throw away the notes. If they try a second recipe later, they forget what the first one said. This means the best ideas get lost, and it's hard to see if different methods are actually agreeing on the same great invention.

IdeaForge is a new system designed to fix this. Here is how it works, explained simply:

1. The Shared Whiteboard (The Knowledge Graph)

Instead of throwing away notes, IdeaForge uses a giant, persistent digital whiteboard called a Knowledge Graph (specifically using a database called FalkorDB).

Think of this whiteboard as a map. Every time an AI agent (a specialized computer program) thinks of something, it draws a dot (a node) and connects it with a line (an edge) to other dots.
One agent draws a "Problem" dot. Another draws a "User Need" dot. Another draws a "Technical Solution" dot.
Crucially, everyone draws on the same map. They don't erase each other's work; they build on it.

2. The Team of Specialists (The Agents)

IdeaForge hires three different "expert chefs," each with their own style, to work on the same problem:

The TRIZ Agent: Looks for technical contradictions (e.g., "We want it stronger, but lighter") and finds engineering principles to fix them.
The Design Thinking Agent: Looks at the human side (e.g., "Who is using this? What hurts them?").
The SCAMPER Agent: Looks at how to twist the idea (e.g., "What if we swap the material?" or "What if we reverse the process?").

Each agent adds their own unique ideas to the shared whiteboard.

3. The "Aha!" Moment (Convergence)

This is the paper's biggest trick. After all three agents have done their work, the system looks for agreement.

Imagine the TRIZ agent draws a line to a solution. The Design Thinking agent also draws a line to a very similar solution. The SCAMPER agent does the same.
The system connects these three lines with a special red string called a CONVERGENT relationship.
The Logic: If three different experts, using three different ways of thinking, all land on the same idea independently, that idea is probably a really good, strong invention. It's like if three different detectives, using different clues, all point to the same suspect; you know you're onto something real.

4. The Scorecard (InnovationScore)

The system doesn't just guess which idea is best; it gives them a score.

High Score: An idea that all three agents agreed on (Convergence) gets a high score.
Medium Score: An idea supported by two agents gets a medium score.
Low Score: An idea only one agent came up with gets a lower score.
It also checks if the idea has been "challenged" by existing work (Prior Art) and lowers the score slightly if it does, just to be safe.

5. Writing the Patent (The Draft)

Finally, the system writes a patent draft. But it doesn't just ask the AI to "write a patent." Instead, it looks at the top-scoring idea on the whiteboard and traces the path back to see why it was chosen.

It says: "Here is the claim. It is supported by this technical principle, this user need, and this transformation."
This makes the patent draft traceable. You can see the exact path of reasoning that led to the idea, rather than just getting a random text generated by a computer.

The Experiment: A Legal Assistant for Rural India

To test this, the researchers used a specific idea: A voice-first legal assistant for people in rural India who speak Hindi.

They let the three agents work on this.
Result: All three agents came up with very similar core ideas (even though they described them differently).
The system connected them with the red "Convergent" strings.
The system calculated a high score for this idea because of the agreement.
It then generated a structured patent draft based on this high-confidence agreement.

What the Paper Does Not Claim

It does not claim that the patents it writes are legally valid or ready to be filed in court. The authors explicitly say these are "research prototypes" and need a real lawyer to check them.
It does not claim that the AI is a genius inventor on its own. The value comes from the structure of comparing different methods, not just the raw power of the AI.
It does not claim to have solved all ethical issues (like giving legal advice to people who might not understand the risks).

Summary

IdeaForge is like a meeting room where three different types of experts (Engineers, User-Experience Designers, and Creative Twisters) are forced to write their ideas on the same giant whiteboard. The system then highlights the ideas where all three experts accidentally agreed. It uses that agreement as a signal that the idea is strong, and then uses that proof to write a better, more logical patent draft. It turns "guessing" into "triangulation."

Technical Summary: IdeaForge

Problem Statement

Current AI-assisted innovation systems predominantly rely on single-methodology approaches (e.g., TRIZ or Design Thinking) executed through sequential prompt-based workflows. These systems suffer from a fundamental structural limitation: they fail to preserve intermediate reasoning states. Consequently, insights generated across different methodologies remain fragmented, lacking traceability, synthesis, and systematic evaluation of novelty. The final patent drafts are often generated directly from raw Large Language Model (LLM) outputs rather than from a structured, grounded analysis, leading to isolated outputs that are never formally reconciled.

Methodology: The IdeaForge Framework

IdeaForge addresses these limitations by treating innovation methodologies as heterogeneous reasoning operators acting over a shared, persistent knowledge graph (KG). The framework integrates three distinct methodologies—TRIZ, Design Thinking, and SCAMPER—through specialist agents that operate over a FalkorDB graph database.

System Architecture

The pipeline consists of eight steps:

Problem Ingestion: A raw idea is converted into a Problem node in the graph.
Specialist Agent Execution:
- TRIZ Agent: Identifies technical contradictions (improving/worsening parameters) and selects inventive principles, generating Contradiction, Principle, and Claim nodes.
- Design Thinking Agent: Generates user personas, jobs-to-be-done, and "How-Might-We" questions, creating UserNeed and Claim nodes.
- SCAMPER Agent: Applies systematic transformations (Substitute, Combine, Adapt, etc.) to generate Transformation and Claim nodes.
- Prior Art Agent: Searches arXiv for related work, creating PriorArt nodes that challenge specific claims.
Convergence Detection: An Embedding Synthesis Agent computes cosine similarity between claims from different methodologies using sentence-transformer embeddings. Claims from distinct methodologies exceeding a similarity threshold (default 0.65) are linked via a novel CONVERGENT edge.
Ranking: An InnovationScore formula ranks claims based on convergent support, methodology diversity, claim strength, and prior art penalties.
Patent Drafting: A Patent Agent retrieves the top-ranked claims and their supporting subgraphs (contradictions, principles, user needs) to generate a structured patent draft, ensuring every claim is traceable to the KG.

Knowledge Graph Schema

The graph utilizes eight node types (Problem, Contradiction, Principle, UserNeed, Transformation, Analogy, PriorArt, Claim) and eight edge types. The core innovation is the CONVERGENT edge, which connects claims from different methodologies when they are semantically similar. This implements "structural triangulation," where independent derivation of a similar claim by multiple reasoning frameworks serves as a signal of non-obviousness.

Scoring Mechanism

The InnovationScore is a weighted heuristic formula:
$Score = w_1 \cdot \text{norm}(\text{convergent\_count}) + w_2 \cdot \text{norm}(\text{diversity}) + w_3 \cdot \text{claim\_strength} - w_4 \cdot \text{norm}(\text{prior\_art\_challenges})$

Convergent Count (0.4): Highest weight, prioritizing claims supported by multiple methodologies.
Methodology Diversity (0.3): Rewards claims grounded in heterogeneous perspectives.
Claim Strength (0.2): Based on the structural rigour of the generating methodology (TRIZ > DT > SCAMPER).
Prior Art Penalty (0.1): A conservative penalty based on keyword overlap with arXiv literature.

Key Contributions

Persistent Innovation Graph: A schema spanning multiple node types that preserves intermediate reasoning states across methodology passes, unlike sequential prompt chains.
Cross-Methodology Convergence: A mechanism using embedding-based similarity to detect and link claims derived independently by TRIZ, Design Thinking, and SCAMPER via CONVERGENT edges.
InnovationScore: A principled ranking formula that quantifies patent candidate strength based on multi-methodology agreement rather than single-agent output.
KG-Grounded Drafting: A patent generation workflow that constructs drafts from structured subgraphs, reducing reliance on unconstrained LLM generation.
MCP Integration: An MCP server exposing graph tools to external agents and IDEs, enabling modular agentic workflows.

Experimental Results

The framework was evaluated on a voice-first legal assistant for rural India and five other domains (healthcare, EdTech, agriculture, accessibility).

Graph Output: The pipeline consistently generated structured graphs (e.g., 16 nodes, 10 edges) containing distinct claims from each methodology.
Convergence: In four of five domains, all three methodologies converged on semantically similar innovation directions (3 convergent pairs), with cosine similarities ranging from 0.817 to 0.837. The healthcare domain showed lower convergence (1 pair), demonstrating the system's ability to detect genuine divergence in reasoning frameworks.
Comparison: Compared to single-methodology baselines, IdeaForge produced richer, more traceable innovation candidates. Single-method runs missed critical dimensions (e.g., TRIZ-only missed user accessibility; Design Thinking-only lacked technical specificity), whereas the full pipeline synthesized these perspectives.
Robustness: The system functioned effectively using TinyLlama (1.1B parameters), demonstrating that the framework's value lies in the graph-structured multi-methodology analysis rather than raw LLM capability.

Significance and Claims

The paper posits that convergence across independent reasoning methodologies is a principled signal of non-obviousness. If TRIZ (contradiction resolution), Design Thinking (user needs), and SCAMPER (systematic transformation) independently produce semantically similar claims, the probability of the underlying innovation being both technically valid and user-relevant is significantly higher.

IdeaForge claims to advance the field of computational creativity and explainable AI-assisted invention by:

Moving beyond isolated, sequential prompt workflows to a graph-native innovation system.
Providing traceability for every patent claim back to specific reasoning paths (e.g., Problem → Contradiction → Principle → Claim).
Offering a discriminative filter that surfaces genuine methodological agreement while correctly identifying ideas where frameworks diverge.

Limitations and Modesty:
The authors explicitly state that IdeaForge is a research prototype. It does not claim to produce legally valid patent applications. The InnovationScore is a heuristic, not a legal assessment of novelty. The prior art search is limited to arXiv, missing commercial patents, and the system relies on LLM quality, with smaller models requiring fallback logic. The framework is designed to augment human innovation analysis, not replace professional legal review.