Compile by Training: Turning Natural-Language Specifications into Local Neural Functions

arXiv · Yuntian Deng, Pengyu Nie, Stuart Shieber · 2026-09-05

This is no longer on the current shelf — shelves rotate as new material clears the bar. The analysis below is unchanged. See what is featured now.

Compile by Training turns natural-language specs into neural functions—bridging the gap between human intent and machine execution with a single training step.

What it does

This paper presents a method to compile natural-language specifications into local neural functions that can be executed directly by a neural network. Unlike traditional compilers, which translate code into machine instructions, this approach learns to map language to neural operations. It uses a training objective that optimizes for both correctness (matching the specification) and executability (producing valid neural functions). The method is demonstrated on a range of tasks, from simple arithmetic to more complex logic, and shows promise for enabling more intuitive human-AI interaction.

Why it matters

For AI practitioners building agentic systems or tools that bridge human intent and machine execution, this paper offers a tantalizing glimpse into the future: what if you could ‘compile’ a user’s instructions directly into a neural function? No more brittle pipelines or manual rule-writing—just a direct translation from language to executable logic. It’s a step toward making AI systems more accessible and adaptable.

How it applies

If you’re working on systems that need to interpret and execute user instructions (e.g., agent frameworks, automation tools, or interactive AI assistants), this method could simplify your pipeline by replacing hand-crafted rules or complex parsers with a single training step. It’s especially relevant for systems that need to adapt to new tasks or user preferences without retraining from scratch.

The short version

What if your agent’s instructions didn’t need a manual—just a compiler?

My take

I’ve spent years building systems that try to interpret human intent, and the biggest pain point is always the gap between language and execution. We’ve tried rule-based systems, LLMs, and hybrid approaches, but they all hit a wall when it comes to translating intent into actionable logic. This paper’s approach—compiling language directly into neural functions—feels like the missing piece. It’s not just a technical trick; it’s a philosophical shift. If this works at scale, it could redefine how we build agentic systems. Imagine an agent that doesn’t just *understand* your instructions but *executes* them directly. That’s the future I signed up for.

How it connects

• This work intersects with the rise of neural symbolic AI and the broader push to make AI more interpretable and controllable.
• It’s a natural evolution of the ‘natural language to code’ trend, but with a neural twist.
• Connects to the agentic systems we’re building, where the ability to interpret and execute intent is critical.

Bottom line

Stop parsing instructions—start compiling them.

Takeaways

• Natural-language specifications can be compiled into neural functions in a single training step.
• The method optimizes for both correctness and executability, ensuring the output is both accurate and usable.
• Enables more intuitive human-AI interaction by bridging the gap between language and execution.
• Potential to simplify agentic systems by replacing brittle rule-based pipelines.
• A step toward making AI systems more adaptable and user-friendly.

Topics: compilation, neural functions, natural-language to code, agentic systems, human-AI interaction