Morph Reflexes offers fast, cheap semantic signals from agent traces using multi-head classifiers on a shared backbone, enabling scalable monitoring of production agents.
The most common failures for production agents are behavioral: looping, reasoning leakage, user frustration, and more. Using a frontier model like GPT or Sonnet to judge every turn is too expensive and slow to run at scale.<p>To solve this, we built Reflexes: semantic signals from agent traces, served fast and cheap over API. Built on custom kernels and a custom inference engine forked from vLLM.<p>Under the hood, it is a small LLM architected around multi-head inference. Small models need to be trained for specific tasks, but running 50 separate small models on the same input for 50 tasks makes no sense.<p>How it works:
We use a modern LLM with hybrid attention and remove the decode step. We built an inference engine that lets prefill compute be 99% reused from reflex to reflex, similar in spirit to older 2019-era BERT/HYDRA and older multiple-head techniques. we built the inference engine to reuse the KV/cache across inputs and compute across all reflexes. One shared backbone reads the trace once, then many heads classify different signals. Our inference engine reuses the same KV/cache and compute across all reflexes, giving us sub-30ms inference with less than 0.1% overhead for each additional reflex.<p>We took the same high-level idea and did the hard work to make it work with a modern architecture and attention. On it, we can run inference in under 30ms and serve the full request in under 90ms. If you run 4 reflexes or 100, the extra overhead is less than 2ms.<p>Why does optimizing this matter?<p>If you’re even a medium-sized startup, you’re dealing with tens of thousands of agent runs and millions of turns. If you want to track things like user frustration rates over time, frontier LLM-as-judge does not scale.<p>I built a similar stack at Tesla. When ML engineers needed to sample data across petabytes for signals like `is_camera_obfuscated=true`, along with 200 other things, you need to 1) spin them up quickly 2) run at scale efficiently<p>What it is not:
A dashboard. 99% of dashboards go unused.
100% API first and made for devs who want to use this to trigger their own stuff.<p>vibetrain a custom reflex in our dashboard, and/or then let it self improve in production: <a href="https://www.morphllm.com/dashboard/reflex">https://www.morphllm.com/dashboard/reflex</a><p>Docs: <a href="https://docs.morphllm.com/sdk/components/reflexes/index">https://docs.morphllm.com/sdk/components/reflexes/index</a><p>I’d love feedback from people running agents in prod: what sorts of things do you wish you could track over time across 100% of turns but cant right now?<p>TLDR: semantic signals from agent traces, super fast, cheap via API
# Show HN: Morph Reflexes – Multi-head classifiers for agent traces
Source: [https://news.ycombinator.com/item?id=48739038](https://news.ycombinator.com/item?id=48739038)
The most common failures for production agents are behavioral: looping, reasoning leakage, user frustration, and more\. Using a frontier model like GPT or Sonnet to judge every turn is too expensive and slow to run at scale\.
To solve this, we built Reflexes: semantic signals from agent traces, served fast and cheap over API\. Built on custom kernels and a custom inference engine forked from vLLM\.
Under the hood, it is a small LLM architected around multi\-head inference\. Small models need to be trained for specific tasks, but running 50 separate small models on the same input for 50 tasks makes no sense\.
How it works: We use a modern LLM with hybrid attention and remove the decode step\. We built an inference engine that lets prefill compute be 99% reused from reflex to reflex, similar in spirit to older 2019\-era BERT/HYDRA and older multiple\-head techniques\. we built the inference engine to reuse the KV/cache across inputs and compute across all reflexes\. One shared backbone reads the trace once, then many heads classify different signals\. Our inference engine reuses the same KV/cache and compute across all reflexes, giving us sub\-30ms inference with less than 0\.1% overhead for each additional reflex\.
We took the same high\-level idea and did the hard work to make it work with a modern architecture and attention\. On it, we can run inference in under 30ms and serve the full request in under 90ms\. If you run 4 reflexes or 100, the extra overhead is less than 2ms\.
Why does optimizing this matter?
If you’re even a medium\-sized startup, you’re dealing with tens of thousands of agent runs and millions of turns\. If you want to track things like user frustration rates over time, frontier LLM\-as\-judge does not scale\.
I built a similar stack at Tesla\. When ML engineers needed to sample data across petabytes for signals like \`is\_camera\_obfuscated=true\`, along with 200 other things, you need to 1\) spin them up quickly 2\) run at scale efficiently
What it is not: A dashboard\. 99% of dashboards go unused\. 100% API first and made for devs who want to use this to trigger their own stuff\.
vibetrain a custom reflex in our dashboard, and/or then let it self improve in production:[https://www\.morphllm\.com/dashboard/reflex](https://www.morphllm.com/dashboard/reflex)
Docs:[https://docs\.morphllm\.com/sdk/components/reflexes/index](https://docs.morphllm.com/sdk/components/reflexes/index)
I’d love feedback from people running agents in prod: what sorts of things do you wish you could track over time across 100% of turns but cant right now?
TLDR: semantic signals from agent traces, super fast, cheap via API
Neural_avb highlights how Minimax M3's RLMs use subagent swarms with pydantic contracts for type checking and schema validation, reducing hallucination rates and failed subagent calls.
Katanemo Labs introduces 'Signals,' a lightweight method for identifying informative agent traces without using LLM judges or GPUs, achieving higher efficiency in trajectory analysis.
NeuroMAS treats multi-agent language systems as trainable neural-network-like architectures with LLM agents as nodes, using reinforcement learning to learn communication and specialization. It shows improved performance and that progressive growth from smaller systems works better than training large systems from scratch.
This paper identifies memory retention as the bottleneck in recurrent memory agents for long contexts and proposes Multi-Head Recurrent Memory (MHM), a training-free framework that partitions memory into independent heads with a select-then-update strategy. The lightweight instantiation MHM-LRU significantly improves retention and end-to-end accuracy across 100K–1M token ranges, raising retention from below 30% to 73.96% on RULER-HQA at 896K tokens.
HyperEyes is a parallel multimodal search agent that uses dual-grained reinforcement learning to optimize inference efficiency, achieving higher accuracy with significantly fewer tool-call rounds compared to existing agents.