For years, Fully Homomorphic Encryption (FHE) has been the “holy grail” of data privacy. The promise is incredible: the ability to compute on encrypted data without ever needing to decrypt it. In a world of constant data breaches and strict privacy regulations, it allows for a “privacy-by-design” economy where sensitive information like medical records or financial history can be analyzed without ever being exposed.
But there has always been a catch. Writing FHE code is notoriously difficult. It requires deep expertise in cryptography, an understanding of complex mathematical constraints, and a mastery of specialized libraries like OpenFHE. For the average Python developer, the learning curve wasn’t just steep; it was a wall.
At Duality, we’ve decided to tear that wall down. By combining Claude Code with our own specialized FHE Domain Skills, we’ve made it possible to generate professional-grade OpenFHE code using nothing but natural language.
How it Works
General-purpose LLMs are often “a mile wide and an inch deep.” If you ask a standard AI to write FHE code, it’s likely to produce code that doesn’t meet privacy and security criteria and often fails to run due to ill-use of the FHE library and unawareness of cryptographic and algorithmic constraints.
Our approach moves beyond simple prompts by encoding years of Duality’s expertise directly into specialized agentic skills. This allows the AI to navigate the technical “magic” of OpenFHE automatically:
1. Strategic Problem Decomposition
In standard programming, we take basic operations for granted. In FHE, operations are conducted on ciphertexts, which requires specific packing of numerical values to accommodate for the necessary arithmetic operations. Furthermore, not all operators are created equal. Some are “heavier” than others (e.g. division, non-linear function, etc.) and require specific treatment within the context of the computation.
- The Agent’s Logic: When calculating a computation such as a Chi-Square statistic, the agent mimics a human expert. It breaks the computation into simple operations and recognizes that division is computationally problematic in the encrypted domain. Then, it reconstructs the compuation and bypasses it in the same manner that an experienced FHE researcher would.
2. Automated Cryptographic Handling
The agent utilizes specialized skills to handle the heavy lifting that usually requires a PhD:
- SIMD Packing: Instead of encrypting numbers one by one, the agent intelligently maps data into vectors so one operation can process thousands of data points simultaneously (using specialized packing strategies).
- Approximation Theory: For tasks like Logistic Regression, the agent knows that Sigmoid functions cannot be computed directly. It automatically implements high-degree polynomials to approximate these functions with high precision, triggering specialized OpenFHE options reserved for expert researchers.
3. Real-Time Validation and Correction
Using a state-of-the-art coding agent, bridges the gap between domain specific knowledge and an executable running FHE code.The AI doesn’t just “guess” the code; it actually executes it in a local workspace. If the OpenFHE library throws an error regarding “insufficient depth” or “parameter mismatch,” the agent reads the error log, adjusts the cryptographic settings while keeping security standards, and re-runs the code until it produces a result that matches the plaintext reference.
The Developer’s New Edge: Beyond the Code
What makes this workflow truly “agentic” is that the AI acts as a collaborative partner. In the OpenFHE ecosystem, “AI slop” code that looks correct but fails on execution or doesn’t meet security standards is a major hurdle. Our skill-based recipes provide the right context at the right time, significantly reducing slop and keeping the agent focused on validated cryptographic patterns.
By using Claude Code, the developer benefits from a closed-loop system. The agent doesn’t just hand you a script; it examines your data structure, derives an FHE-friendly version of your algorithm, and performs the necessary validation to ensure the cryptographic parameters are secure and precise. It removes the final barrier between a complex math problem and a production-ready privacy solution.
Use case examples:
| Use Case | Technical Achievement | Key FHE Operations |
| Chi-Square Stats | Constructed a contingency table in the clear and then intelligently encrypted/processed it. | EvalMult, EvalRotation, EvalAdd |
| Logistic Regression | Applied approximation theory to run risk score analysis on pre-trained models with precise cryptographic parameters. | Parameter Scaling, Approximation theory |
| CNN Convolution | Demonstrated the potential for secure neural networks by generating runnable Python code for deep learning layers. | Vector Packing, Bootstrapping |
Expanding the Horizon: Real-World Use Cases
While the technical demos show how the code is built, the real impact of accessible FHE is seen in how it transforms industries that handle sensitive data:
- Healthcare Research: Multi-institutional studies can run genomic analysis on siloed patient data without ever moving the raw data or risking patient anonymity.
- Financial Anti-Fraud: Banks can collaborate to identify global fraud patterns by checking their private customer lists against shared “blacklists” without revealing their proprietary client information to competitors.
- Supply Chain Integrity: Companies can verify the compliance and security of third-party vendors’ components using encrypted audits, ensuring integrity in sensitive manufacturing without exposing trade secrets.
- Personalized Medicine: Clinicians can analyze a patient’s genetic markers (SNPs) against encrypted databases to tailor treatments, ensuring the patient’s most personal data is never stored in a vulnerable state.
See it in Action
We’ve recorded a deep-dive demonstration that walks through the entire workflow, from entering a natural language prompt into the Claude Code interface to seeing the agent validate the code and produce results identical to standard SciPy references. You can see the agent deriving FHE-friendly algorithms and decomposing complex problems exactly like an experienced data scientist would.
Conclusion: The Future is Privacy-by-Design
The “Privacy Gap” is closing. Until now, building a secure computation flow required a specialized research team. Now, it requires a clear description of your goals in English. At Duality, we are removing the final barrier to a digital economy where sensitive data can be fully utilized without ever being exposed.
The future of privacy is no longer a research project, it’s a line of code away.
