imtt-dev

steer

Python2025–2026

imtt-dev / steer

steer

The Active Reliability Layer for AI Agents. Catch failures, teach fixes, and automate reliability

AI & Machine Learning Observability

Explore on GitHub Read Hacker News discussions

2Distinct people

10Mentions

0Explicit recommenders

135GitHub stars

REPOSITORY AT A GLANCE

What to know before exploring

What it is

The Active Reliability Layer for AI Agents. Catch failures, teach fixes, and automate reliability

GitHub

Where it is used

No documented product use has been verified yet.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 1:49:46 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by week10 dated mentions

Observed mentions: 2025-12-02 14:16:31 UTC to 2026-01-20 21:02:34 UTC. Weeks start Monday, UTC.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges

UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
Period	Start (UTC)	End (exclusive, UTC)	Mentions	Submissions	Comments
Dec 1	2025-12-01 00:00:00 UTC	2025-12-08 00:00:00 UTC	2	1	1
Dec 8	2025-12-08 00:00:00 UTC	2025-12-15 00:00:00 UTC	1	1	0
Dec 15	2025-12-15 00:00:00 UTC	2025-12-22 00:00:00 UTC	3	1	2
Dec 22	2025-12-22 00:00:00 UTC	2025-12-29 00:00:00 UTC	0	0	0
Dec 29	2025-12-29 00:00:00 UTC	2026-01-05 00:00:00 UTC	0	0	0
Jan 5	2026-01-05 00:00:00 UTC	2026-01-12 00:00:00 UTC	2	0	2
Jan 12	2026-01-12 00:00:00 UTC	2026-01-19 00:00:00 UTC	1	1	0
Jan 19	2026-01-19 00:00:00 UTC	2026-01-26 00:00:00 UTC	1	0	1

What Hacker News says

10 sources

steer_dev·Jan 20, 2026

The Data: Green Line (Capability): MMLU State-of-the-Art (48% → 94%). Red Line (Control): Organizations with effective mitigation for inaccuracy/hallucination (lagging at ~52%). Sources: MMLU: Official Repository (hendrycks/test) and Model Technical Reports. Risk: McKinsey “State of AI” Annual Reports (2023–2025). The Gap: Intelligence is surging. Control is lagging. We are currently in the gap (High capability, low trust). How are you solving the gap? Potential Solution: Move verification outside the model using deterministic “Reality Locks” (Regex, SQL AST, Entropy) Repo: https://github.com/imtt-dev/steer

In The "Confident Idiot" Problem: Intelligence vs. Control (2021-2026)

steer_dev·Jan 12, 2026Submission

Show HN: I got tired of "Reliability Spaghetti," so I monkeypatched PydanticAI

Author of the "Confident Idiot" post here (https://news.ycombinator.com/item?id=46152838). After that discussion, I looked at my own agent code and realized it was 80% error handling and 20% reasoning. I was manually decorating every function with retries, regex checks, and JSON validators. It was unreadable. I realized that reliability shouldn't be Application Code; it should be Infrastructure. I built Steer to test a pattern: Monkeypatching the framework to decouple reliability. Instead of decorating functions, I initialize Steer at the entry point. It hooks into the framework's lifecycle (PydanticAI / OpenAI), introspects the tools, and attaches "Reality Locks" (SQL parsers, Schema checks, Entropy filters) globally. Before (The Spaghetti): # Business logic mixed with safety logic @retry(stop=stop_after_attempt(3)) def run_query(q

Read the rest

): if "DROP" in q: raise Error() # Manual check response = agent.run(q) if not is_valid_sql(response): raise Error() # Manual check return response After (The Mesh): import steer # One line patches the framework globally. # Auto-attaches SQL validators to any tool returning SQL. steer.init(patch=["pydantic_ai"], policy="strict_sql") # Pure Business Logic agent.run(query) It currently handles SQL AST validation, PII redaction, and a "Slop Filter" (using Shannon Entropy to block apologies). It’s open source and local-first. I’m curious if anyone else is using this "sidecar" pattern or if you prefer explicit middleware? Repo: https://github.com/imtt-dev/steer

2 points · Open discussion

steer_dev·Jan 8, 2026

AI Slop (apologies, filler) isn't just annoying; it is In-Band Signaling Noise. The model mixes control signals (persona) with data (payload). Prompting ("Be concise") is brittle. I switched to Shannon Entropy. The Hypothesis: Code/Data is mathematically "messy" (High Entropy). Slop is smooth and predictable (Low Entropy). I wrote a filter that blocks responses if entropy dips below ~3.5. The Payoff: It captures the blocked slop as a dataset for DPO. I use the math to gather data today so I can fine-tune a natively quiet model tomorrow. Repo: https://github.com/imtt-dev/steer

In Detecting "AI Slop" with Shannon Entropy (Python)

steer_dev·Jan 6, 2026

Doing post-mortems on my agent's failures over the holidays made me realize the problem isn't the model. It is the lack of a deterministic inference-time verification layer. I spent the break reading the recent Stanford/Harvard paper on agentic adaptation [1]. Their research provides mathematical proof for what I experienced in Q4: supervising only final outputs is a dead end. Agents learn to "ignore tools and improve likelihood," meaning they learn to lie more convincingly to pass evaluations while the underlying logic rots. I call this the Agent Lobotomy. The agent I have in production today is significantly dumber than the one I demoed in December. I was forced to strip autonomy, remove context, and add human checkpoints because I could not trust the probabilistic output. We are stuck in an Autonomy Retreat, creating an Authority Bottl

Read the rest

eneck [2] where agents are relegated to assistive tasks because the tail risk of autonomous action is too high. I built Steer (open source) to stop the bleed. In v0.4.0, I moved the architecture to an Agent Service Mesh pattern. Instead of decorating every function, you patch the framework (e.g. PydanticAI) at the entry point. It auto-discovers tools and enforces a reliability policy globally via deterministic Reality Locks. The real unlock is the data. By capturing the delta between a Blocked Response and a Taught Fix, Steer acts as a synthetic data factory for DPO. It moves reliability from a runtime tax to a training asset, allowing you to eventually refactor your prompt monolith into fine-tuned model weights. I've put together three cookbooks showing how this stops the lobotomy in SQL and RAG workflows: 1/ Framework Patching: https://github.com/imtt-dev/steer/blob/main/steer/cookbook/p... 2/ SQL Security Lock: https://github.com/imtt-dev/steer/blob/main/steer/cookbook/s... 3/ RAG Grounding Guard: https://github.com/imtt-dev/steer/blob/main/steer/cookbook/r... References: [1] https://arxiv.org/abs/2512.16301 [2] https://cloudedjudgement.substack.com/p/clouded-judgement-12...

In The Agent Lobotomy: Inference-time verification for autonomous systems

steer_dev·Dec 18, 2025

OP here. I’ve realized that a 3,000-token system prompt isn't "logic", it's legacy code that no one wants to touch. It’s brittle, hard to test, and expensive to run. It is Technical Debt. My thesis is that we need to stop treating prompts as the "program" and start treating them as temporary specs that eventually get compiled into the model weights via fine-tuning. I built Steer (open source) to automate this "refactoring" process. It helps you climb the "Deliberation Ladder": 1. The Floor (Validity): Use Steer's deterministic verifiers (regex, AST, JSON Schema) to block objective failures in real-time. Don't ask an LLM if JSON is valid; check it with code. 2. The Ceiling (Quality): Use `steer export` to turn those captured failures into a fine-tuning dataset, training the model to handle nuance and "vibes" without a massive prompt. Curio

Read the rest

us if others are seeing this "Prompt Bloat" in production? Repo: https://github.com/imtt-dev/steer

In Prompt Engineering Is Technical Debt

steer_dev·Dec 16, 2025

OP here. Last week I posted a discussion ("The Confident Idiot Problem") about why we need deterministic checks instead of just "LLM vibes" for reliability. That thread [1] blew up, so I’m sharing the open-source implementation (v0.2) that solves it. Steer is an active reliability layer for Python agents. It sits between your LLM and the user to enforce hard constraints. Unlike passive observability tools that just log errors, Steer creates a feedback loop: 1. Catch: It uses deterministic verifiers (like Regex, AST parsing, JSON Schema) to block hallucinations in real-time. 2. Teach: You fix the behavior in a local dashboard (`steer ui`). 3. Train: v0.2 adds a "Data Engine" that exports these runtime failures into an OpenAI-ready fine-tuning dataset. The goal isn't just to block errors; it's to use those errors to bootstrap a model that s

Read the rest

tops making them. It is Python-native, local-first, and framework agnostic. Repo: https://github.com/imtt-dev/steer [1] https://news.ycombinator.com/item?id=46152838

In Show HN: Steer (v0.2) – Active reliability layer for AI agents (Python)

steer_dev·Dec 16, 2025Submission

Show HN: Steer (v0.2) – Active reliability layer for AI agents (Python)

1 points · Open discussion

mooreds·Dec 9, 2025Submission

The Active Reliability Layer for AI Agents

1 points · Open discussion

steer_dev·Dec 5, 2025

OP here. I wrote this because I got tired of agents confidently guessing answers when they should have asked for clarification (e.g. guessing "Springfield, IL" instead of asking "Which state?" when asked "weather in Springfield"). I built an open-source library to enforce these logic/safety rules outside the model loop: https://github.com/imtt-dev/steer

In The "confident idiot" problem: Why AI needs hard rules, not vibe checks

steer_dev·Dec 2, 2025Submission

Show HN: Steer – Stop debugging agents, start teaching them (Open Source)

Hey HN, I’m the author. I built Steer because I was tired of the 'Confident Idiot' problem—where agents output broken JSON or hallucinate facts, and I only find out when the app crashes. Existing tools just log the error. I wanted to fix it. Steer creates a local feedback loop: 1. Catch: It blocks the bad output (e.g., Markdown in a JSON field). 2. Teach: You click 'Teach' in the local dashboard to define the fix. 3. Fix: It injects that rule into the agent's context for future runs. It’s Python-native, works with any LLM (OpenAI/LangChain/etc), and stores data locally. pip install steer-sdk Repo: https://github.com/imtt-dev/steer I’d love feedback on the API design—specifically the @capture decorator pattern.

2 points · Open discussion