cs.PLMar 29, 2026

DriftScript: A Domain-Specific Language for Programming Non-Axiomatic Reasoning Agents

Authors: Seamus Brady

Organizations: Independent Researcher, Dublin, Ireland

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

Non-Axiomatic Reasoning Systems (NARS) provide a framework for building adaptive agents that operate under insufficient knowledge and resources. However, the standard input language, Narsese, poses a usability barrier: its dense symbolic notation, overloaded punctuation, and implicit conventions make programs difficult to read, write, and maintain. We present DriftScript, a Lisp-like domain-specific language that compiles to Narsese. DriftScript provides source-level constructs covering the major sentence and term forms used in Non-Axiomatic Logic (NAL) levels 1 through 8, including inheritance, temporal implication, variable quantification, sequential conjunction, and operation invocation, while replacing symbolic syntax with readable keyword-based S-expressions. The compiler is a zero-dependency, four-stage pipeline implemented in 1,941 lines of C99. When used with the DriftNARS engine, DriftScript programs connect to external systems through four structured callback types and an HTTP operation registry, enabling a sense-reason-act loop for autonomous agents. We describe the language design and formal grammar, detail the compiler architecture, and evaluate the compiler through a 106-case test suite, equivalence testing against hand-written Narsese, a NAL coverage analysis, structural readability metrics, and compilation benchmarks. The source code is available at https://github.com/seamus-brady/DriftNARS. This paper focuses on the design and implementation of the DriftScript language and its embedding into DriftNARS, rather than on new inference algorithms for NARS itself.

Figures & tables

CopulaNotationMeaning
Inheritance-->“is a kind of”
Similarity<->“resembles”
Implication==>“if … then” (eternal)
Temporal implication=/>“if … then” (temporal)
Equivalence<=>“if and only if”
Table 1: Narsese copulas
ConnectorNotationMeaning
Sequential conjunction&/Events in temporal order
Conjunction&&Both hold
Disjunction||At least one holds
Negation--Negation
Product Ordered tuple
Extensional set{…}Specific individuals
Table 2: Narsese connectors
DriftScriptNarseseMeaning
(inherit A B)<A --> B>A is a kind of B
(similar A B)<A <-> B>A resembles B
(imply A B)<A ==> B>If A then B (eternal)
(predict A B)<A =/> B>If A then B (temporal)
(equiv A B)<A <=> B>A iff B
(instance A B)<A |-> B>Instance relation
Table 3: DriftScript copulas and their Narsese equivalents
DriftScriptNarseseArityNotes
seq&/2–3Sequential conjunction
and&&2Conjunction
or||2Disjunction
not--1Negation
product 1+Product
ext-set{…}1+Ext. set
Table 4: DriftScript connectors
PrefixTypeNarseseNAL role
$Independent1,1 , 2Universal-like
#Dependent#1 , #2Existential-like
?Query?1 , ?2“What fills this?”
Table 5: DriftScript variable types
Figure 1: Integration of DriftScript with DriftNARS in a sense–reason–act loop.
CategoryTestsCoverage
Tokeniser14Parens, keywords, strings, escapes, comments
Parser6Atoms, nested lists, errors
Copulas8All 6 copulas + arity errors
Connectors17All 14 connectors + arity errors
Call shorthand4Bare ops, with args, errors
Sentences12All forms, tenses, truth, dt
Table 6: Compiler test suite summary
NALConstructDriftScriptNotes
1Inheritanceinherit 
2Similaritysimilar 
2InstanceinstanceSugar for |->
3Set operationsext-set , int-set 
3Intersection/diffext-inter , etc.4 operators
4ProductproductN-ary
Table 7: NAL coverage. All entries marked “Covered” have compiler test cases and produce correct Narsese output.
MetricDriftScriptNarseseRatio
Total characters6934121.68 ×\times
Symbol characters1071670.64 ×\times
Distinct symbols8200.40 ×\times
Alphabetic chars4521862.43 ×\times
Alpha / total0.640.44—
Table 8: Structural comparison (15 representative programs)
Appendix figures & tables1 asset

Supplementary material from the paper’s appendix.

Appendix

#DriftScriptNarsese
1(believe (inherit "robin" "bird"))<robin --> bird>.
2(believe (similar "cat" "dog"))<cat <-> dog>.
3(believe (imply "rain" "wet"))<rain ==> wet>.
4(believe (predict "A" "B"))<A =/> B>.
5(believe (equiv "A" "B"))<A <=> B>.
6(believe (instance "Tweety" "bird"))<Tweety |-> bird>.
Appendix
Table 9: DriftScript to Narsese translation examples

Explore similar work

CardsList
Apr 20, 2026

From Natural Language to Executable Narsese: A Neuro-Symbolic Benchmark and Pipeline for Reasoning with NARS

Large language models (LLMs) are highly capable at language generation, but they remain unreliable when reasoning requires explicit symbolic structure, multi-step inference, and interpretable uncertainty. This paper presents a neuro-symbolic framework for translating natural-language reasoning problems into executable formal representations using first-order logic (FOL) and Narsese, the language of the Non-Axiomatic Reasoning System (NARS). To support this direction, we introduce NARS-Reasoning-v0.1, a benchmark of natural-language reasoning problems paired with FOL forms, executable Narsese programs, and three gold labels: True, False, and Uncertain. We develop a deterministic compilation pipeline from FOL to executable Narsese and validate retained examples through runtime execution in OpenNARS for Applications (ONA), ensuring that the symbolic targets are not only syntactically well formed but also behaviorally aligned with the intended answer. We further present Language-Structured Perception (LSP), a formulation in which an LLM is trained to produce reasoning-relevant symbolic structure rather than only a final verbal response. As an initial proof of concept, we also train and release a Phi-2 LoRA adapter on NARS-Reasoning-v0.1 for three-label reasoning classification, showing that the benchmark can support supervised adaptation in addition to executable evaluation. Overall, the paper positions executable symbolic generation and execution-based validation as a practical path toward more reliable neuro-symbolic reasoning systems.

Mina Gabriel, Pei Wang

Temple University, Philadelphia, PA 19122, USA

Logical ReasoningReasoning EvaluationSymbolic ReasoningNeuro-Symbolic Reasoning
AskPDF
Oct 24, 2026

FlashScript: Compiling Recurring Agent Workflows into Reusable Neuro-Symbolic Programs

Many agent tasks recur with new data or small changes, yet agents regenerate their reasoning and actions on each run, producing different results. Distilling a prior run into a skill helps the agent avoid earlier mistakes, but it still re-runs the full process each time, so runs can vary and incur that cost. We compile a successful agent run into a reusable neuro-symbolic program (NSP) with a set of guidelines we call FlashScript. Actions and data transformations become code, instance-specific values become parameters, and decisions that need model judgment become LLM calls. We identify three layers where these calls belong and three techniques that replace most of them with code. The compilation does not remove nondeterminism; it localizes it, so the deterministic program and its neural calls can be reviewed and tested separately. Across 120 WorkBench analytics tasks with Claude Haiku 4.5, the NSPs were correct and made identical tool calls on every run, using about 70 times fewer input tokens and a third of the runtime of a skill-guided agent whose runs were inconsistent. In a composite version of the tasks, the skill-guided agent's accuracy fell to 23%, and its output inconsistency increased, while the NSPs remained correct and identical across all runs. The NSPs successfully generalized to all 108 unseen instances of the same templates. Our findings suggest that NSPs from agent trajectories can be considered cumulative software assets for end-users to test, maintain, and reuse in their recurring workflows.

Sadra Sabouri, Hosein Hasanbeig, Adam Sage +6

University of Southern California, Los Angeles, CA · Microsoft, Redmond, WA

LLM Agent Workflow OptimizationLLM-Based Program SynthesisProgram SynthesisLLM Agent Trajectory Synthesis
AskPDF
Aug 9, 2026

IDRAAK: From Multi-Agent NLP to Few-Shot Prompting for Semantic Drift Detection in Technical Requirements

Translating technical requirements across languages can introduce semantic drift, altering numerical constraints, polarities, modalities, or other specification-critical meaning. IDRAAK is presented as an interpretable framework for detecting such drift using a language-independent Semantic Requirement Representation (SRR), with six detection workflows evaluated, ranging from deterministic comparison to multi-agent verification and few-shot prompting. On 890 synthetic perturbations across 300 requirements from 10 engineering domains, a single LLM call with six few-shot examples achieves MCC=0.888 and F1=0.983, outperforming the evaluated structured and multi-stage alternatives. Further evaluation on PAWS-X (805 pairs, 5 languages) and XNLI (700 pairs, 7 languages) exposes complementary strengths and limitations of structured and LLM-based approaches. Deterministic SRR comparison performs strongly on technical requirements (F1=0.898) but poorly on general-domain text (F1=0.012), while structured evidence improves performance on adversarial paraphrases. Post-hoc Platt scaling further improves confidence calibration. The results demonstrate that increased agentic complexity does not necessarily improve semantic-drift detection and that simple few-shot prompting can provide a strong and efficient alternative.

Shiva Ahir

Department of Electrical & Computer Engineering Stony Brook University New York, United States of America

Requirements EngineeringFew-Shot PromptingMT Evaluation
AskPDF