Project summary

I have actually worked on creating a representational aware controller which works in a closed loop setting (currently in review at TMLR). My research concerns understanding when an LLM makes a pressured reversal: the properties of input text that make an LLM "lie" and how to steer it back to neutrality. Phase one of the research can be found here: https://rajarshighoshal.github.io/deception-pressure-geometry/. For the steering, I designed a representation-aware controller which reads residual and attention views and steers activations from the falsified zone to the neutral zone. It works via editing the state (the internal activation space) and observing if the space is in a safe zone now. It was successfully transferred from Llama-3.1-8B to Qwen3-8B, where Qwen reused the Llama-learned state after refitting the observation and edit maps, improving correct answers by +8.75 and +6.25 pp on 240 held-out cases per model while keeping neutral answers in 143/144 cases on Llama and 155/164 on Qwen.

There are issues with the current controller: it is data starved, it only works in a very specific situation, its representational geometry is incomplete, and it is very costly to run as it is at inference time in Python hooks one chat at a time. Good news is it works and I already have ideas to refine and extend it inside vLLM on the GPU during the forward pass so the runtime cost is low enough for real serving.

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

While current systems work using linear detection, vector interventions, or external LLM as a detector, a major flaw is that linear detectors collapse in OOD, vector steering works only in certain situations and can degrade output quality, and external LLM-based classifier-style systems can fire in unrelated situations. My proposal is instead to create an external representational controller coupled with the model's internal state at inference time inside vLLM.

In month 1, I will port the Llama and Qwen controller into vLLM and measure the runtime cost against stock vLLM from batch size 1 to 64. In months 2 and 3, I will cut that cost using fused Triton/CUDA kernels, CUDA graphs, and a masked batch edit instead of branching per sequence. Because fused attention in vLLM does not materialize the full attention weight matrix in memory, I will test cheaper approximations for the attention signal and check how much correction accuracy drops. In months 3 to 5, I will work on this controller to generalise it beyond the current single-turn scenario to test on multi-turn chats, general prose, and agent action space across a third model family, and in month 6 I will release the vLLM code, benchmark, and writeup.

How will you know it worked?

As AI systems get deployed in more critical systems, it is important to reduce error rates in statistically significant ways while keeping behavior within standard expectations. I will know this worked if the correction rate inside vLLM matches my offline code within its confidence interval on the 240 held-out cases, neutral answers stay at the offline rate (143/144 on Llama and 155/164 on Qwen), throughput loss at batch 32 stays under 5% vs stock vLLM, and it transfers across three model families.

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

The design I have come up with depends on smooth transition between the safe and unsafe regions in the manifold. So if it turns out that in general multi-turn cases the manifold transition between unsafe to safe zones is cliff, the proposed controller fails as it depends on editing the space and observing immediately. If that happens or if getting the attention view inside fused vLLM kernels costs too much latency, I will ship a residual-only version of the vLLM controller,publish the kernel profiling numbers, and release the negative result and test suite (as I did in Phase 1 and in https://github.com/rajarshighoshal/computation-boundary-evidence).

How will this funding be used?

I need $45,000 for 6 months full-time ($7,000 per month stipend which is $42,000, plus $3,000 for GPU compute to run the vLLM benchmarks and model sweeps). The minimum bar is $24,000 for a 3-month version ($21,000 stipend and $3,000 for GPUs) where I ship the inline vLLM controller, fused kernels, and benchmark on two models without the multi-turn agent part or third model family.

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

Just me (M.S. CS, Machine Learning, Georgia Tech, May 2026).

• BlueDot public report (phase one): [https://rajarshighoshal.github.io/deception-pressure-geometry/](https://rajarshighoshal.github.io/deception-pressure-geometry/); this was the first prototype of the proposed controller failed badly but gave invaluable lessons for next step
• ACL 2026 SRW paper: [https://aclanthology.org/2026.acl-srw.13/](https://aclanthology.org/2026.acl-srw.13/); here I have studied how internal activations can be used to understand behavioral changes before the outputs
• SC26 programme page: [https://sc26.conference-program.com/presentation/?id=pap693&sess=sess217](https://sc26.conference-program.com/presentation/?id=pap693&sess=sess217); fast parallel k-clique counting I worked on creating the independent set counter; the key insight was to reformulate the clique counting problem as complementary independent set counting problem which attacks the representational space and gives large speedup by reading the search tree depth (1,356x on my step, 16,631x on 192 cores for the full team system)
• Previously Senior ML Engineer at Microsoft Azure OpenAI (owned GPT-4o and GPT-4o mini release validation and latency testing, cutting release evals from 3-4 days to 1), Senior ML Engineer at REAL Brokerage (agent verification layers and Temporal pre-merge gates), and Senior Data Scientist at IBM (built the 13-model code-generation eval standard).

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

$100 for compute from a BlueDot Impact Rapid Grant in June 2026