Project Chimera: Neural-Symbolic Expert Systems for Explainable AI

Project Chimera aims to resurrect the expert system paradigm—once dominant in AI but abandoned due to brittleness and maintenance burdens—by fusing it with modern deep learning. The core idea is a two-layer architecture: a knowledge graph (KG) capturing domain concepts and rules, and a graph neural network (GNN) that reasons over this KG. Domain experts define rules in natural language, which are parsed and stored as graph edges. The GNN then answers queries by propagating attention along rule paths, producing not just an answer but a traceable explanation. This hybrid approach promises the best of both worlds: the transparency and debuggability of rule-based systems, and the flexibility and learning capability of neural networks. The project envisioned applications in high-stakes domains like medical diagnosis, where interpretability is critical, and aimed to build a prototype that doctors could interact with. It would start with a curated oncology knowledge base and demonstrate how the system could suggest treatments while explaining its reasoning. The plan was ambitious, requiring advances in neural-symbolic integration and knowledge graph inference, and remained in the planning stage as the research challenges proved too deep for a small team to tackle.

Modern deep learning models are black boxes, hard to debug, and require massive datasets. Expert systems, on the other hand, are transparent but static and brittle—they cannot learn from new data and require manual rule updates. This leaves a gap: there is no AI system that is both interpretable and adaptable, that can start with expert knowledge and improve over time. In domains like medicine, law, or engineering, where explanations are mandatory and data is scarce, this gap is critical. The itch is to build a system that domain experts can understand and trust, yet that evolves with experience.

• Develop a hybrid inference engine that uses graph neural networks to reason over a knowledge graph of rules.
• Create a user interface for domain experts to author and update rules in natural language.
• Demonstrate the system on a complex domain (e.g., medical diagnosis) with fully transparent explanations.
• Achieve comparable accuracy to pure neural models while maintaining complete explainability.
• Enable incremental learning: the system should refine its rule applications based on feedback.

• Not a replacement for end-to-end deep learning on unstructured data (images, raw text).
• Not a fully automated rule learning system—domain experts must remain in the loop.
• Not targeting real-time inference at this stage.
• Not attempting to discover novel causal relationships; only to reason over given rules.

• Python as the primary language.
• PyTorch and PyTorch Geometric for graph neural network implementation.
• Neo4j or RDF triplestore for storing the knowledge graph.
• OWL/RDF ontologies for formalizing domain concepts.
• spaCy and Hugging Face Transformers for parsing natural language rules.
• Custom rule interpreter and query parser.
• Flask or FastAPI for the backend API.
• React for the frontend interface.

The system has two main layers: the Knowledge Layer and the Neural Reasoning Layer. The Knowledge Layer consists of a knowledge graph where nodes represent entities (e.g., symptoms, diseases, treatments) and edges represent relationships or rules (e.g., 'if symptom then disease'). Rules are authored by experts via a natural language interface, then parsed and stored as graph patterns. The Neural Reasoning Layer implements a Graph Attention Network (GAT) that takes a query and the current state of the KG, then performs multi-hop reasoning by attending over rule edges. The output is a ranked list of answer nodes along with an attention trace that serves as an explanation. The system is designed to be query-driven: given a scenario, it computes the most likely conclusions and shows the reasoning path. The architecture supports both forward chaining (inference from facts) and backward chaining (goal-driven queries). Training the GNN involves generating synthetic inference examples from the KG and using reinforcement learning to align reasoning with expert feedback.

• Neural-symbolic integration remains an open research problem; achieving reliable reasoning without catastrophic forgetting is challenging.
• Knowledge graph construction for new domains is labor-intensive and may require significant expert time.
• Explanations from attention mechanisms may not be fully transparent to non-technical users.
• The system might inherit biases from expert-authored rules or from neural training data.
• Scalability issues as the knowledge graph grows large.

• How to handle contradictory rules gracefully (e.g., different sources give conflicting advice)?
• Should the reasoning be differentiable all the way to enable end-to-end training from user feedback?
• What is the optimal granularity for rule representation (atomic vs. composite)?
• Can we automatically detect missing rules or knowledge gaps?
• How to measure and guarantee the correctness of explanations?

The project remained a planning-stage concept because the core research challenge of seamless neural-symbolic integration was too daunting without a dedicated research team and long-term funding. As the team's interests shifted toward more immediate applications, the plan was shelved—not out of failure, but because the timing and resources weren't right. It remains a compelling 'what if' that could be picked up again as the field matures.

This project was inspired by the strengths of early expert systems like MYCIN and the potential of modern graph neural networks. The name 'Chimera' reflects the hybrid nature. The plan assumed a small team of 2-3 researchers and a domain expert over 18 months.