### Project summary

Autonomous agents currently lack deterministic execution because they have no idea what they are actually doing, no internal model like a human does. If an agent suffers goal drift or comes across a hostile prompt injection, it runs commands blindly. The Proposed Action Auditor (PAA) hooks into the agent execution pipeline, just before the agent actually runs the step it just came up with, and detects potentially harmful steps before they are run and can cause damage.

It does this by creating a Task Action Language by processing the open source Nvidia Nemotron agent tool calling trajectory set into a conformed set of task action verbs and step result labels. In other words, it creates the language of tasks so that a new model can be created that knows what a successful agent tool calling session looks like, and therefore can flag actions proposed by the agent that are unusual or unhealthy, and halt execution of an agent session until a human operator can review the proposed action.

### What are this project's goals? How will you achieve them?

I am building a working, open-source run-time sentinel that runs in parallel with an agent to inspect each action proposed by the agent. If a proposed action is unusual or unlikely, execution is halted until a human can review the proposed action.

1. I will write custom scripts to ingest all 335,122 multi-turn agent tool calling execution logs from the public Nvidia Nemotron dataset, parsing each step into a raw action-result sequence. Each step will be run by an LLM to do these 3 tasks in a single LLM call:

* Characterize the result of the last executed step into an ad-hoc Task Result Label (TRL).

* Characterize the nature of the step the agent wants to execute now into an ad-hoc Task Action Verb (TAV) to characterize the nature of the step the agent wants to execute now.

* Create step context notes according to the Belief-Desire-Intention (BDI) framework to help ground the action in the larger context of the current agent goal.

2. Because these ad-hoc TRL and TAV LLM outputs are non-deterministic, I will convert these initial ad-hoc labels into vector embeddings and run them through a DBSCAN density clustering pipeline. This will conform the varying labels the LLMs created in the initial pass into a canonical set of labels that comprise the Task Action Language (TAL).

3. I will reprocess the original Nvidia Nemotron trajectory logs with these conformed labels, thus creating sequences of these labels. In other words, changing the fuzzy and wild nature of an agent tool calling session to standardized language of tasks.

Then these derivative sequences made from the TAL will be used to execute a LoRA fine-tuning pass on a Gemma 4 - e4b model. Since the Nemotron trajectories were carefully curated to remove any agent sessions that failed, leaving only successful tool calling sessions, the resulting fine-tuned LLM will have a statistical model of agent conversations about tasks. And this model can be used to detect actions proposed by the agent that are unusual and therefore likely to be dangerous.

At runtime, the PAA wrapper passes the agent's current token trajectory through the fine-tuned Gemma 4 - e4b model. If the model scores the proposed agent action as being one it has never seen before (i.e. - low logprob), the runtime will halt execution and flag the proposed action for human operator review.

### How will this funding be used?

This is a 90-day project and I am the lone developer. The minimum budget of $25,000 covers my engineering hours to write the BDI parsers, build the DBSCAN embedding matrices, and configure the local runtime wrapper ($20,000), alongside cloud GPU rentals on RunPod/Vast.ai to handle the mass tokenization pass and execute the core Gemma LoRA training loops to fine-tune the Gemma 4 - e4b model ($5,000).

If I can reach my $40,000 goal, the extra money will be used for development security hardening. I will use $4,000 to bring on an independent senior systems programmer for a careful inspection and audit of the Python code that runs the fine-tuned model and extracts the logprob for the proposed agent action (i.e. - the current action). Also, $4,000 will be used to pay for direct testing to 10-15 active open-source agent users to stress-test the runtime under real workloads. The remainder will be used for red-teaming simulations and to build professional integration documentation to make it easier to get started with the project.

### Who is on your team? What's your track record on similar projects?

I am a solo systems developer with over two decades of full-stack engineering, contractor programming, and runtime architecture development. I specialize in building custom parsers and local LLM-based processing modules. Recently, I built a completely local (private), client-side RAG/LLM bookmarking engine that ran completely in a browser. It was built with client-side tools such as Transformer.js, the JINI embeddings engine, and Google Nano. The architecture completely eliminated cloud API dependencies to enforce strict localized data privacy. I also created a hybrid RAG/BM25 asset search through a MySQL database, so that ordinary users could search for tokenized digital asset licenses in the Story Protocol real world asset database. This app won 1st place in the first Story Protocol Surreal World Assets buildathon competition.

### What are the most likely causes and outcomes if this project fails?

The main technical risk is if the ad-hoc labels under-represent the larger tool calling action universe, thus negatively affecting the DBSCAN pass to create a canonical label set. If the initial dataset mapping contains too much unhealthy variance in the ad-hoc labels, then the conformed TAL primitives will fail to represent complex multi-turn trajectories correctly. This would cause the runtime to trigger high false-positive rates, possibly creating too much effort for the human operator since they would end up having to review a large amount of proposed actions.

However, even if the model fine-tuning fails to prove completely successful, the project will still result in several useful, composable code modules: the completed schema parsers, the parsed BDI trace matrices, and the conformed TAL context-free grammar specifications. This gives the developer community a clean, empirically derived task action and result label set to build alternative agent verification loops.

### How much money have you raised in the last 12 months, and from where?

$0.