With over 20 years of experience, we transform your digital presence. We specialize in website and E-Shop development, SEO and Digital Marketing, ERP software and smart automation that take your business to the next level.
Address:
154 Egnatia Street, Thessaloniki 546 36
Phone:
+30 231 231 4095
E-mail:
hello@twodots.gr
Ready for the next step?;
See how EvoPINN transforms an AI agent into a controlled algorithm discovery loop, featuring execution, a shared budget, diagnostics, and rigorous verification.
What if an AI system weren't limited to writing code, but could propose a new algorithm, execute it, identify its errors, and retain only what proves to be best? The paper EvoPINN: Agentic Discovery of Executable Algorithms for Physics-Informed Neural Networks examines precisely this transition. Its focus is specialized—solving differential equations with physics-informed neural networks — but the architectural thinking behind the system is relevant to any business that wants to use agentic AI for design, optimization, or research.
See how EvoPINN transforms an AI agent into a controlled algorithm discovery loop, featuring execution, a shared budget, diagnostics, and rigorous verification. The key message is not that an LLM «became a scientist.» The authors present a controlled framework where language generation is linked to rigorous verification, a shared computational budget, and actual execution. Thus, the model’s creativity is not treated as proof. Each proposal must pass technical checks and measurably reduce error before being incorporated into the evolutionary chain.
Short answer: EvoPINN does not trust the AI agent's proposal. It executes the proposal in an isolated environment, checks its structure and resources, compares it to the parent algorithm within a shared budget, and retains it only when it reduces the measurable error.
Physics-informed neural networks, or PINNs, approach the solution to a partial differential equation by incorporating physical laws into the loss function. Instead of being trained exclusively on input-output pairs, they penalize violations of the equation, boundary conditions, and, where necessary, initial conditions. This is an attractive mesh-free approach, but its performance depends on many interrelated decisions.
The representation of coordinates, the network architecture, the weighting of individual losses, the collocation points, and the sequence of optimizers can drastically change the result. Furthermore, different physical behaviors require different mechanisms: oscillatory solutions require frequency sensitivity, while nonlinear transport problems require stability near steep gradients. As the study emphasizes, there is no single, one-size-fits-all design that works everywhere.
This makes the field both suitable and risky for LLM automation. A model can easily generate code that appears reasonable but is mathematically invalid, numerically unstable, or more expensive than its competitor. Without execution and verification, apparent innovation may simply be a well-written failure.
Previous approaches primarily automate the selection of known settings—depth, width, activation functions, optimizers, or combinations thereof—within a predefined search space. Even agentic systems such as PINNsAgent and Lang-PINN, according to the authors’ comparison, compose pipelines or select configurations within human-designed boundaries.
EvoPINN raises the level of the search object. It defines a PINN algorithm as a pair of two programming modules: the first describes the neural representation, and the second describes the training program. The agent can programmatically replace one or the other, so it doesn’t just search for «what value to set,» but «which mechanism to execute.».
For a product or R&D team, this is a critical distinction. Configuration search chooses among options that someone has already conceived. Mechanism discovery allows the system to propose a new structure, but requires much stricter governance because the scope of possible changes is open-ended. The same distinction is evident when AI optimizes executable kernels for TPUs: Quality is judged by actual runtime performance, not by how elegant the code is.
From the selection of settings to the controlled discovery of mechanisms
It selects depth, width, activation, or optimizer within a range that has already been defined by a human.
The agent writes a new module, but syntactic correctness alone does not prove arithmetic validity.
The training trace and errors are returned as a specific diagnosis for the next mutation.
Only structurally new, feasible, and better results within the given budget are carried over to the active lineage.
If both the network and the training process are changed at the same time, it is difficult to know what caused the improvement or the failure. EvoPINN addresses this problem with module-wise evolution: in each generation, it modifies only the representation or only the training program, keeping the other constant.
The selection is not made through rigid switching. A UCB-style scheduler combines the recent benefit from each module with the need to explore the less-tested ones. The logic is familiar from the exploration–exploitation trade-off: the system capitalizes on what works, without leaving a potentially useful direction unexplored.
This clearly translates to business experimentation. When a team changes the prompt, retrieval, model, UI, and security rules all at once, an improved KPI does not reveal which change worked. Breaking things down into controlled modules creates an audit trail and makes improvements more repeatable. That’s the practical side of it. Credit assignment to AI agents: Change one thing at a time so you can figure out which change actually helped.
A single relative-L2 error indicates whether the candidate algorithm was better, but not why. EvoPINN condenses the training trace into a diagnostic state: convergence progress, end-of-training behavior, oscillations, the contribution of physical constraints, and the distance between the training loss and the actual solution error.
This state is fed into the LLM so that subsequent suggestions target the observed problem. A steady training process may lead to a different suggestion than one with strong oscillations. The study does not allow the model to interpret raw logs arbitrarily; it uses a compact, well-defined diagnosis as a framework.
At the same time, evolutionary memory stores successful patterns, persistent families of failures, and recent changes. Different search focuses encourage parallel proposals to examine another aspect—feature construction, topology, coordinate transformation, loss coordination, or sampling—in order to reduce mode collapse.
The core idea behind EvoPINN is that no generated program is selected simply because it sounds convincing. It is first compared to its parent at the source code level, the standard abstract syntax tree (AST), and the normalized AST. By normalizing private identifiers and numeric literals, the system filters out cosmetic rewrites, renaming, and changes to constants only. The authors correctly point out that this is a practical check for structural originality, not a proof of semantic novelty.
Next, the candidate must be parsed, loaded as a module, comply with the interfaces, and pass a smoke test. The following are checked: forward computation, derivatives, backpropagation, optimizer, sampling interfaces, device placement, finite values, resource bounds, and a brief training process. Repairable failures are returned to the generator for a limited number of corrections; invalid mechanisms or resource violations result in a new proposal from the parent.
Only those that pass the gates are executed within the full budget. Even then, a proposal becomes part of the active lineage only if its score is significantly better. This pattern—generate, validate, execute, compare, accept—is much more transferable to businesses than any specific PINN result. It complements the idea of AI-powered skills: The rule or code must demonstrate its functionality beyond the linguistic response.
A «better» algorithm may simply use more steps or more data. To mitigate this pitfall, EvoPINN evaluates candidates using a shared training budget and a shared random seed per generation. The budget covers optimization steps, initial collocation points, and adaptive sampling checks.
Candidates can creatively reallocate resources, but they cannot arbitrarily increase the computational footprint. The best search result is frozen and retrained from scratch on five independent seeds. The single-run search score is not presented as the final result, which reduces the risk of selecting a randomly favorable run.
The controlled budget for the EvoPINN evaluation
The figures describe the specific protocol of this study and do not constitute a general cost benchmark for every AI agent.
Poisson2D, Burgers1D, Wave1D, and Heat2D cover different physical behaviors.
The upper bound in comparison with LLM Best-of-56, DPSTE, and PINNsAgent.
The full-scale nominal budget that candidates could reallocate, but not exceed.
The frozen algorithms were retrained from scratch for the baseline results.
Depending on the PDE, automated discovery took between 14.70 and 51.78 GPU-hours on an NVIDIA RTX 3090 24GB. This serves as a reminder that agentic research is not free. The cost of evaluation must be factored into the design and not an afterthought following the experiment.
The authors evaluated frozen algorithms on Poisson2D, Burgers1D, Wave1D, and Heat2D, covering elliptic, nonlinear transport, wave, and anisotropic thermal behavior. With a lower relative-L2 indicating a better solution, EvoPINN outperformed seed PINN on all four benchmarks.
Compared to specialized expert baselines, it had the lowest mean error on Poisson2D, Burgers1D, and Wave1D. In Heat2D, the expert-designed anisotropic Fourier baseline maintained a slight lead, while EvoPINN remained close behind. The detail matters: the paper does not claim universal superiority.
In a separate comparison with a cap of 56 candidate evaluations, EvoPINN had the lowest reported error on Burgers1D and Wave1D compared to LLM Best-of-56, DPSTE, and PINNsAgent. Here, the authors’ interpretation is that execution feedback, memory, and module-wise mutation allow for exploration beyond predefined templates.
The most notable architectural innovation is the SLRC-PINN for Burgers1D. It combines global and local branches, an adaptive bank of local bases, and a gate that controls only the corrective path. The last layer of the local decoder starts with zero weights and bias, so its initial operation is exactly the same as the global branch before it learns the correction.
The study compares the mechanism with parameter-matched global MLP, APINN, FBPINN, and HyResPINNs, using a common equation, collocation, objective, 20,000 Adam–L-BFGS steps, and five seeds. The authors present it as a case study of the mechanism and distinguish it from the frozen Burgers1D winner in the main table.
TCROP reveals the other side: a training program for Poisson2D. It maps the diagnostic state to the distribution of Adam and L-BFGS steps and to the refresh rate of collocation points. Thus, the agent did not merely discover topology; it formulated a coordinated policy for optimization and resampling.
The team removed the diagnosis, allowed simultaneous changes to both modules, and restricted the search to either representation or training only. The full version achieved the best results on Burgers1D and Wave1D under a common seed, proposal budget, and evaluation protocol.
Without diagnostics, the performance degradation was particularly severe in Wave1D. The simultaneous mutation of the two modules caused execution instability, while unilateral searches lagged behind. The findings support—within these specific benchmarks—that representation and optimization dynamics require co-design, but with changes sufficiently isolated so that credit assignment remains clear.
The transfer test to neighboring parameters also yielded positive results. The frozen algorithms for Wave1D and Heat2D were retrained on shifted parameters without a new search and maintained competitive performance. This is a limited indication of adaptability, not proof of generalization to every PDE.
The first lesson is to treat the agent’s output as a candidate, not a final deliverable. Code, campaigns, automation rules, or pricing proposals all require automated gates before they go into production. These gates must verify validity, compatibility, cost, security, and measurable outcomes.
The second is the preservation of lineage and memory. A list of past responses is not enough; the record must document what change was made, what diagnosis prompted it, whether it was implemented, and why it was rejected. This limits the repetition of failed ideas and allows the team to explain the origin of a result.
The third point is fair evaluation. If an agent wins because it consumed twice as many tokens, time, or human supervision, we haven’t necessarily found a better method. We need shared budgets, independent retests, and a reporting set different from the one used for selection. The audit trail must also show Who takes over when automation fails?, while the agent's tools require minimal and dynamic rights.
Six gates for an operational agent that proposes changes
Specify which module can be modified, how much time, tokens, or compute resources it is allowed to consume, and which data remains inaccessible.
Run generated code or an automation rule in a sandbox with a timeout, memory limits, action logging, and no unchecked permissions.
Reject anything that does not parse, does not comply with the contract, produces infinite values, requires unauthorized tools, or violates policy.
Use the same inputs, the same limits, and a clear baseline so that any improvement is not due to a hidden increase in resources.
Record the diagnosis, the exact differential diagnosis, the result, the cost, and the reason for accepting or rejecting each proposal.
Run the winner again on a new reporting set and require human approval before any change affects customers, funds, or production systems.
For operational use, these gates are linked to two external reference standards: the NIST AI RMF requires risk measurement, monitoring, and governance, while the OWASP AI Agent Security Cheat Sheet places practical emphasis on least privilege, sandboxing, validation, monitoring, and human approval for high-impact actions.
This work concerns four PDE benchmarks and a specific infrastructure. Structural AST checks do not prove that a mechanism is theoretically novel. Reference solutions are used for outer-loop selection, so the setup requires a reliable evaluation to be available. The compute cost also limits how easily the search can be expanded.
The authors themselves identify the extension to more PDEs and broader scientific applications as a future direction. For a business reader, the correct conclusion is not that «agents will discover everything.» Rather, it is that open production gains value when it is framed by clear interfaces, telemetry, verification, resource constraints, and strict acceptance criteria.
The criterion prior to production
An agent has not discovered an improvement until it has executed it, compared it fairly, and repeated it.
Το EvoPINN αξίζει κυρίως ως αρχιτεκτονικό μάθημα: περιορισμένος χώρος δράσης, συγκεκριμένο feedback, μηχανικοί έλεγχοι, μετρήσιμο αποτέλεσμα και δυνατότητα απόρριψης σε κάθε στάδιο.
Business automation and AI from TWO DOTS
Σχεδιάστε AI agents που αποδεικνύουν κάθε αλλαγή πριν την παραγωγή.
Η TWO DOTS συνδέει agents, επιχειρησιακά δεδομένα και εργαλεία με σαφή permissions, validation gates, observability, budget controls και ανθρώπινη έγκριση.
Frequently Asked Questions (FAQs)
It is a research framework in which an LLM agent suggests feasible changes to the neural representation or the training program of a physics-informed neural network and retains only those that pass the checks and reduce the error.
The code undergoes structural review, is loaded into an isolated subprocess, passes smoke tests, and is evaluated using a shared computational budget before it is considered a candidate for improvement.
No. The study demonstrated the effective identification of candidate mechanisms in four specific PDE benchmarks. The scientific validity continues to depend on the human-designed protocol and the reference solutions.
It is a global–local architecture developed for Burgers1D, featuring adaptive local bases, a gated corrective branch, and zero initialization of the local output.
Separating the representation from the training program makes it easier to assign credit: the system can link an improvement or failure to that specific change.
Candidates within a generation shared the same nominal resource envelope and seed. The full-scale limit was 20,000 optimization steps, while the frozen winners were assigned five independent seeds.
The paper reports 14.70 to 51.78 GPU-hours per designated source search, depending on the PDE, on an NVIDIA RTX 3090 24GB. This is not a general cost estimate for other applications.
Treat every proposal from the agent as a potential change: with limited permissions, isolated execution, a shared budget, clear acceptance criteria, lineage, independent iteration, and human approval.
