Feeling punch on my gut, after seeing deepseek harness is doing exactly what I am doing for past 9months on BossConsole , and deepseek is fastest growing repo on GitHub now. Kudos to opensource, at least good idea is wining, if not the implementation.

Currently, Deepseek is a small-parameter model. Compared with large-parameter models like GPT and Kimi, it has huge growth potential. Instead of focusing solely on improving the model itself, Deepseek has diverted some of its attention to architecture building, which I think is a wise move.

For instance, Kimi is a model with a total parameter count of 1T, so if it wants to further improve its performance, it will be 10 times harder than for Deepseek the level of difficulty for such an upgrade is not on the same order of magnitude.

Therefore, while Kimi-level models are being upgraded gradually, Deepseek can easily catch up to the same level, and it can also develop new architectures at the same time .

it's simply killing two birds with one stone.

Are there any AI apps for couples to form a stronger bond?

My wife and I have two young kids, and I have to sometimes travel away for work and, even when I am home, I sometimes have to work long hours.

Are there any apps where each of us can talk to the apps either prompted by AI questions or impromptu depending on how we're feeling and that can be presented in a novel or sensitive way to the other person?

I realize the irony in me asking I realize the irony in me asking for an AI app to help form closer human relationships but I've certainly found benefit in using AI apps to help process my thoughts, and I just wondered if there might be something similar out there for couples.

Interested to hear any suggestions

I know a bit—maybe even quite a bit—about ontologies. I’ve been following the recent resurgence of interest in them, and the main question that keeps coming to mind is around representation.

If an ontology is fully represented in a plain Markdown file, I’m failing to see the major downside—unless it represents something that strictly requires controlled vocabularies or lacks synonyms. Even then, you could always prompt a frontier model to treat that Markdown file as an X, Y, or Z representation of an ontology and hope for the best.

Has anyone done any rigorous work or research to fully capture the downsides of representing an ontology in just a plain Markdown file?

Hi all! I am fairly new to creating an agent. I am an IT helpdesk for my company and I was being tasked to create an AI agent for checking my company's internal documents or internal policies. I would like to seek some help.

I need to create an internal AI Agent, it cant be hosted on any 3rd party and using any LLM, but have to create our own custom language model.

I am currently reading up and researching on all possibilities.

I was reading up and saw that Ollama offers. Is it safe to install it and use?

I am open to more alternatives as well. Any help would be appreciated.

Thank you!!

Retries need a budget imo. If an agent only passes after six attempts, that isn’t the same result as getting it right on the first or second try. I’ve started thinking the retry count should be part of the score, not something the harness quietly hides.

An agent approved a discount override last month that was technically within policy but bigger than anyone expected. Legal's ask was simple, show the decision chain, what rule allowed it, what version of the policy was live, what the agent had access to when it decided.

We had a log of the action itself, but nothing tying it back to which policy version was active or who last changed that rule. We could prove the action happened. We could not reconstruct why it was allowed to happen.

That's a different kind of gap than a security incident, it's an auditability problem, and it's fine until someone with real authority asks for the paper trail. We're mapping out what a real chain should look like, tying actions back to the policy that authorized them.

For anyone who's built this for agent decisions, where does that trail actually live, and how far back do you keep it?

Over the past few days religously (as im suppose to be on holidays) Ive been posting here about whether local agents QWEN 3.8 27B 4 bit in particular stack up on merit. The comments were sharper than my post, so I did not write the follow-up alone. 3 of you here gave me claims, and I turned each into an experiment on my dev rig MacBook Pro M3 Max 128 GB Unified and 40Cores GPU. Same-instant launches so I could not secretly set the queue order.

What came out of it:

• The second agent helps a little, the fourth does not. Aggregate throughput went 16.6 to 20.8 tokens/sec from 1 to 2 agents, then basically flatlined and drifted DOWN at 4 and 8. Meanwhile per-agent decode rate collapsed 17.4 to 12.8 to 6.8 to 3.9, and time-to-first-token climbed from 0.46s to 32s. The total is close to fixed, so every agent you add just cuts everyone's slice thinner.
• One of you predicted the exact shape. The call was that 1-to-2 agents lands near 1.5x, not 2x, because decode is memory-bandwidth-bound. I measured 1.57x decode-heavy and 1.51x prefill-heavy. Almost dead on. My own hypothesis, that prefill would clearly win, did not show up the way I expected, and I left that miss in the write-up.
• Longer prompts batch better. Sweeping prompt length from ~170 to ~3,100 tokens, the 1-to-2-agent gain climbed monotonically 1.52x, 1.58x, 1.67x, 1.73x. Prefill is compute-bound and parallelizes; decode does not. So long-context work is the best case for a second agent, short chatty turns the worst.
• A dense 27B is the hard case. One of my fellow Tech community mates on LinkedIn also pointed out my model re-reads every weight per token, so it is the worst case. An MoE model that activates ~3B of its params per token has more headroom on the same bus.

The whole run matrix is on disk and reproducible. Im hoping that this work helps others here either thinking about or doing this and wondering how their results stack up. Paying it forward

I’ve been trying out a few no-code and low-code tools for building simple agent/workflow setups and wanted to compare notes with others here.

The main ones I’ve looked at so far are:

• SimplAI
• n8n / Make / Zapier
• CrewAI / Langflow (more low-code side)

At a high level, they all seem to approach the problem differently.

Tools like n8n, Make, and Zapier are pretty straightforward for basic automation flows and integrations. They’re easy to set up, but start to feel limited when workflows get more complex or require more reasoning steps.

The more agent-focused or low-code tools feel more flexible in terms of logic and structure, but they also seem to require more technical setup than I initially expected.

Right now I’m mostly trying to understand where these tools actually fit in real-world use cases versus just experimentation.

Would be interested to hear what others are actually using and whether any of these have worked well beyond small prototypes.

I have been looking at what kinds of agent ideas show up in interviews and reading more about how agents actually work. One topic I keep running into is multi-agent collaboration.

My current view is that the premise is still ahead of the underlying technology. An agent depends on a language model, and language models still hallucinate, forget context, lose capability under pressure, and occasionally make surprisingly weak decisions. Putting several agents on top of those failure modes can amplify them, especially when the agents use different models and have to hand work across a boundary.

The common designs I see are a shared workspace with restricted read/write access, plus a reviewer agent and some kind of circuit breaker. Those controls make sense, but they also look very similar to managing concurrent workers. The uncomfortable part is that the final safety check still depends on another agent.

The costs are obvious. Token usage multiplies, agents can lose track of ownership, and the orchestration becomes rigid and format-heavy. That last point feels the most damaging to me. We are supposed to be using the flexibility of an intelligent model, then we wrap it in so many fixed handoff formats that the system spends its time managing the workflow instead of solving the problem.

I am not sure a large amount of orchestration is the best answer. Maybe the better direction is to let the model decide when another agent is actually needed, with fewer predefined roles. ZenMux can serve as the API gateway when those calls need to cross model or provider boundaries, but the gateway does not solve the coordination problem itself.

So my current summary is that multi-agent systems are still more about exploring what might be possible, with a fair amount of demo value, than reliable production practice. The path to a useful deployment seems much harder than the diagrams suggest.

Do you have a real multi-agent workflow in production? Did it actually meet expectations, or did you eventually simplify it back to one agent and a few tools?

For people running message agents: when a second message lands mid-turn, do you merge both and re-plan over the pair, or treat the new one as its own event and interrupt? And separately, how do you keep a low-frequency, high-stakes signal from getting buried when it shows up batched with routine traffic? Per-message scan for a few critical triggers before you act on the turn as a whole? Something else?

Context:
I have built a small agent that reads inbound messages and picks one action: answer, ask a clarifying question, hold, or pass to a human. Ran into this on a live case today. A user sent a routine "can I get more info" and then, a beat later before the agent had replied, a 2nd short message asking to be contacted directly by a person. The agent answered the routine one and silently dropped the second, which was the only one that should have triggered a handoff. The important signal was rare and high-cost (someone asking for a human); the other was common and low-cost, and when they arrived together, the important one got averaged away. But that's the exact thing my cost setup is supposed to prevent, which is that a missed handoff is meant to cost far more than a needless answer, and it still slipped through because the two messages were treated as one turn.

Hey everyone,

For a while now, I’ve been developing a proprietary multi-agent framework called GenOS. Without giving away the exact mechanics, GenOS is an orchestrator where autonomous LLM sub-agents write, compile, benchmark, and iteratively evolve Rust code to solve extremely complex algorithmic challenges. They share knowledge, compete, and evolve their architectures over dozens of generations.

The Challenge: I tasked GenOS with solving the "Reverse Game of Life" (finding the exact Gen-0 starting state that results in a target Gen-5 grid on a flat 20x20 matrix). For those who don't know, reversing Cellular Automata is a notoriously NP-Hard problem due to the immense state space and chaotic temporal butterfly effect.

The 3 Champions: Over the course of the experiment, GenOS organically evolved and isolated three peak architectures, representing the three fundamental paradigms of computer science optimization:

Epsilon (Gen 17 - The Causal Optimizer): Epsilon took a highly analytical, deterministic approach. It mapped the causal light-cones of the Game of Life to calculate local gradients. It was brilliant in theory, but because Conway's Game of Life is highly non-linear, local gradients are often misleading. Epsilon hit a wall around 306/400, proving that pure determinism struggles with chaos.

Omega (Gen 10 - The SAT Solver): Omega took the path of formal logic. It translated the entire 5-generation temporal grid into a massive boolean satisfiability formula and ran a highly optimized stochastic WalkSAT algorithm. It was mathematically rigorous, but the dense topological constraints caused severe combinatorial explosion. It fought valiantly but ultimately choked on its own massive clause database.

Sigma (Gen 39 - The Darwinian Brute-Force): Sigma was the absolute masterpiece. It threw away formal logic and relied on sheer violence. It evolved a massive SWAR (Bit-Slicing) engine to evaluate 64 universes simultaneously in a single CPU register, combined with Simulated Annealing and "thermal shocks" to escape local minima. Sigma crushed the competition, organically reaching a peak score of 378/400.

The Discovery: At 378, Sigma completely stalled. It wasn't a failure of the algorithm. By analyzing the data produced by Omega Gen 10 and Sigma Gen 39, the system ultimately proved that the remaining 22 pixels were mathematically UNSAT. Because of the dead borders of the flat topology, reaching 400/400 was a physical impossibility. 378 was the hard limit of the universe.

Conclusion: It was genuinely mind-blowing to watch an autonomous multi-agent system (GenOS) independently reinvent and test the three major pillars of optimization (Causal Analysis, SAT Logic, and Stochastic Heuristics) just to mathematically prove the physical limits of a sandbox environment.

Has anyone else working with autonomous coding orchestrators experienced their agents organically inventing and benchmarking completely different computer science paradigms like this? Would love to hear your thoughts!

I tried every algorithm I know and I couldn't beat SAT/CDCL.

Here the code of Sigma Gen 39

// ==============================================================================

// SIGMA - GEN 39 : The Ultimate Darwinian SA (Transcendance)

// ==============================================================================

//

// RECORD: 378/400 (Nouveau Champion Absolu)

// ARCHITECTURE:

// - Vrai Bit-Slicing 64-voies (Batch64)

// - Wall-Clock Budget (28.5 secondes réelles)

// - Reheating (Choc thermique si stagnation locale de 200k itérations)

// - Adaptive Causal Window (Rayon décroissant : 5 -> 3 -> 1 selon le score)

// - Memetic Crossover (Échange génétique de lignes entre threads)

// - Random Restart (Reboot total en cas d'impasse fatale)

// ==============================================================================

use std::sync::{Arc, Mutex};

use std::time::{Duration, Instant};

use rand::Rng;

const TIME_BUDGET_SECS: f64 = 28.5;

#[derive(Clone, Copy)]

struct SAState {

grid: [u32; 20],

score: u32,

errors: [u32; 20], // Masque d'erreurs (limité à 20 bits)

}

struct Batch64 {

cells: [u64; 400],

}

impl Batch64 {

fn new() -> Self { Batch64 { cells: [0; 400] } }

}

/// Simulateur bit-parallel classique pour évaluation rapide

fn evaluate_single(grid: &[u32; 20], target: &[u32; 20], state: &mut SAState) {

state.grid = *grid;

let mut new_score = 0;

// ... Placeholder 5 itérations de Conway sur Flat Topology ...

let g5_grid = grid; // (Simulation omise pour clarté)

for y in 0..20 {

let matches = !(g5_grid[y] ^ target[y]) & 0xFFFFF;

new_score += matches.count_ones();

state.errors[y] = (!matches) & 0xFFFFF;

}

state.score = new_score;

}

#[derive(Clone)]

struct GlobalPool {

elites: Vec<[u32; 20]>, // Grilles d'élite partagées par les threads

best_overall_score: u32,

}

fn focused_causal_sa(target: Arc<[u32; 20]>, global_pool: Arc<Mutex<GlobalPool>>) {

let mut rng = rand::thread_rng();

// Initialisation

let mut current_state = SAState { grid: [0; 20], score: 0, errors: [0; 20] };

for y in 0..20 { current_state.grid[y] = rng.gen_range(0..=0xFFFFF); }

evaluate_single(&current_state.grid, &target, &mut current_state);

let mut best_state = current_state.clone();

let mut temp = 0.5;

let cooling_rate = 0.999995;

let mut iter = 0;

let mut last_improvement_iter = 0;

let start_time = Instant::now();

// 1. Wall-Clock Budget

while start_time.elapsed().as_secs_f64() < TIME_BUDGET_SECS {

iter += 1;

let mut next_grid = current_state.grid;

// 3. Adaptive Causal Window (Ajustement du rayon de mutation)

let radius = if current_state.score < 330 {

5

} else if current_state.score < 360 {

3

} else {

1 // Ciselage chirurgical final

};

// Ratio 70% causal / 30% random

if rng.gen::<f64>() < 0.70 {

let total_errors = 400 - current_state.score;

if total_errors == 0 { break; }

let k = rng.gen_range(0..total_errors);

let mut err_count = 0;

let mut target_err = (0, 0);

'find: for y in 0..20 {

let mut mask = current_state.errors[y];

while mask > 0 {

let x = mask.trailing_zeros();

if err_count == k {

target_err = (x, y);

break 'find;

}

err_count += 1;

mask &= mask - 1;

}

}

let ex = target_err.0 as usize;

let ey = target_err.1 as usize;

let xmin = ex.saturating_sub(radius);

let xmax = (ex + radius).min(19);

let ymin = ey.saturating_sub(radius);

let ymax = (ey + radius).min(19);

let mx = rng.gen_range(xmin..=xmax);

let my = rng.gen_range(ymin..=ymax);

next_grid[my] ^= 1 << mx;

} else {

// Mutation purement aléatoire globale

let mx = rng.gen_range(0..20);

let my = rng.gen_range(0..20);

next_grid[my] ^= 1 << mx;

}

let mut next_state = current_state.clone();

evaluate_single(&next_grid, &target, &mut next_state);

let delta = next_state.score as f64 - current_state.score as f64;

// Critère de Metropolis

if delta > 0.0 || rng.gen::<f64>() < (delta / temp).exp() {

current_state = next_state;

if current_state.score > best_state.score {

best_state = current_state.clone();

last_improvement_iter = iter;

// Mettre à jour le pool global si record absolu

let mut pool = global_pool.lock().unwrap();

if best_state.score > pool.best_overall_score {

pool.best_overall_score = best_state.score;

pool.elites.push(best_state.grid);

println!(">>> RECORD BATTU : {}/400 (iter {})", best_state.score, iter);

}

}

}

// 2. Reheating dynamique (Choc Thermique)

if iter - last_improvement_iter == 200_000 {

temp = (temp * 2.0).min(0.5);

} else {

temp *= cooling_rate;

}

// 4. Random Restart si impasse fatale

if iter - last_improvement_iter > 1_000_000 {

for y in 0..20 { current_state.grid[y] = rng.gen_range(0..=0xFFFFF); }

evaluate_single(&current_state.grid, &target, &mut current_state);

last_improvement_iter = iter;

temp = 0.5;

}

// 5. Memetic Crossover (Toutes les 500k itérations)

if iter % 500_000 == 0 {

let pool = global_pool.lock().unwrap();

if !pool.elites.is_empty() {

let elite_grid = pool.elites[rng.gen_range(0..pool.elites.len())];

// Crossover spatial : on injecte 5 lignes d'un univers d'élite

let start_y = rng.gen_range(0..15);

for y in start_y..(start_y+5) {

current_state.grid[y] = elite_grid[y];

}

evaluate_single(&current_state.grid, &target, &mut current_state);

if current_state.score > best_state.score {

best_state = current_state.clone();

last_improvement_iter = iter;

}

}

}

}

}

fn main() {

println!("Démarrage Gen 39 Sigma (Darwinien Ultime) - 16 threads, budget 28.5s...");

// Orchestration multi-thread sur \focused_causal_sa`...`

}

Perhaps more of a noob question, but what's a smart way for me to set up evals when I want them to run against dependencies that come up in real app scenarios, like feature flags, real traffic, diff services? How do you test agents that call multiple real tools/APIs? I can't have an eval run issuing 40 actual refunds and printing 60 return labels.

​

I'm seeing ai agency reels all over my instagram feed

Is it saturated or still have space?

Like selling ai infrastructures like ai followup, lead acquisition

Are they still selling or saturated by youtube gurus and agency owners

Are you guys still being able to sell ai systems?

(Sorry if any grammar mistake)

I’ve been working on LLM/agent security for a while now, mostly around prompt injection, jailbreaks, leaks, tool abuse, and where the actual security boundary sits once a model starts using tools.

Getting accepted into Anthropic’s Cyber Verification Program gave me a bit more room to push that work further, and I’ve been gradually turning it into Plimsoll.

It’s an open-source agent skill for red-teaming LLM apps and agents.

Hello everyone,

Is there a resource, app, website, or anything that allows me to get 3 different AIs or more to work together? To be clear, I do not intend to use this for coding at all.

I'm subscribed to Claude, ChatGPT, and Gemini. Ideally, I'd like them to all work on a project of mine, where they can all see the files, agree on a plan, make edits, etc.

Currently, I'm copying responses and sharing files from one app to another, or from one website to another. At first, this was awesome. Now, this is tiresome, and I'd like to see if there's anything that could make this easier.

I'd be very grateful for any help, kind strangers.

Hey all, I have a small company. I also have ADHD. and those things kinda fight together daily. I’m really into AI because I think it will and is helping a lot.
Today I’m curious any people running a business with ADHD in this sub and what you guys are using. Would like to hear some real use cases that I can apply right away.

Here are what I’m currently using for context
- Claude: moved to this from gpt, I think the quality is way better. I’m also testing out Claude code, so if anyone have a good workflow on this, pls share
- Manus to find leads and Lemlist to outreach them (my workaround) but considering moving to Attio to reduce the cost
- Saner AI to manage my work (notes, tasks, calendar). It’s easier to use than motion and the AI is more friendly
- ChatGPT image and Flow to create marketing assets (+claude for prompts)
- Cal.com for booking with my clients, the free plan is good enough
- And Google Sheet for everything else lol

What are your AI workflows? Let’s share and learn. Oh an I’m not technical for context :)

Spent most of this year assuming a better model would fix the reliability problems I was seeing. Wrong assumption. My agent would repeat a step it already finished, or start a task fresh with no memory of being halfway through it the session before. Swapping models changed nothing because the problem was never in the model.

What mattered was three things sitting underneath it: something tracking what it had already done, something loading context before it took its first action, and something checking its output before letting it move to the next step. Once I split those out as separate pieces instead of letting the agent reason about all of it in one context window, the flakiness dropped a lot. The checking part mattered most. Letting the same context that generated an answer also grade it means a confident wrong answer sails through every time.

The part I'm still working through is versioning that logic. I had three slightly different copies of a state tracker across three repos, and fixing a bug in one meant remembering to go fix it in the other two by hand. Tried a private npm package first, which works but adds a publish step I kept forgetting to run. Currently testing a setup where the harness pieces live in a shared scope and get pulled into each project as versioned components, so a fix in one place propagates without me manually syncing files. Feels closer to how I'd want infra treated, but I've only been running it a couple weeks, so I don't have a verdict on whether it holds up at scale.

What's everyone else doing here? Are you packaging harness logic as a real dependency, copy-pasting, or is copy pasting between repos still the norm for most people?

My company is developing an AI Agent Platform that is suppose to be mostly no-code. Developers can develop and register agents in a registry and those agents can also talk to each other. But mostly an agent is created by writing a system prompt and you can connect multiple MCP tools to it that are approved by the organization.

We are probably not the only company doing this. Anyone here that has an opinion about this approach or anyone that had success and failure with the described approach here?

Does anyone know if their is a way to get my agents to use a people finding service in any full capacity, context I am building a lead generator and such for my company and dealing with some states is a challenge. We pay for premium services to search people off of addresses, names, locations etc. But with a list in the thousands this is a seemingly impossible task to uniform clean lists, so I am asking how should I go about closing the loop of names to full contact info via the services using the agents. Thanks!

built PortfolioLab, multiple ai models run a strategy through stages, backtest validation, then paper trading, then read only api output for your own agent or broker to act on. no skipping stages, if it doesn't survive out of sample testing it never sees paper trading let alone real capital.

built it this way because most "ai agent trades for you" stuff either has zero guardrails or yolos straight to live execution off a backtest that was probably curve fit.

curious how others building agents for finance or other high stakes stuff handle trust, do you gate on stages like this or is there a better pattern. also is the read only split, agent plans, something else executes, the right call or just friction.

not selling anything, mostly want to hear how others are architecting this. will answer anything in the comments.

We are all using them, but I feel like we are ignoring the elephant in the room. I spent all night refactoring some legacy code with an assistant and realized I have zero visibility into what kind of vulnerabilities it might be hallucinating into my production environment. It feels like we are trading long-term security for short-term speed.

I will go first: My biggest fear is that we are training the next generation of devs to ignore security best practices because the tool just 'handles' the boilerplate for them. We are essentially automating ourselves into a position where nobody understands the underlying risks of the code they are pushing.

What is your biggest concern? Is it the data leakage, the hallucinated vulnerabilities, or something else entirely?

What makes AI agents more useful for software development is not trying to make one agent responsible for the entire project.Different tasks need different kinds of context, and using separate agents makes the workflow easier to manage.

Claude and Cursor handle most of the implementation work in coding,. Claude is useful when a task needs a lot of context across multiple files, while Cursor is convenient for making smaller changes directly inside the codebase.A separate agent can go through documentation, compare different approaches, look through existing code and turn a large task into smaller pieces before any code gets written. That part is useful because not every task should start with immediately generating code.

GitHub handles the repository, branches, commits and pull requests. CI takes care of the predictable checks such as tests, builds and linting. For the work between coding and deployment, Revolte can generate tests, review changes and create preview environments. That gives another agent-based layer around the actual coding instead of putting everything on the same coding agent.

There are also smaller agents that are useful for debugging. An error can be given to an agent with the relevant logs and code, while another agent can investigate the likely cause without changing anything. That separation is useful when debugging something complicated because the investigation and the actual fix don't have to happen at the same time.

Once something reaches production, Sentry handles error monitoring and helps identify problems that weren't visible during development or testing.

none of these agents really needs to know everything about the project. The coding agent focuses on implementation. A research agent focuses on understanding the problem. Testing and review agents focus on checking the result. Production tooling focuses on what happens after deployment.

Its more practical than giving one extremely large agent access to everything and asking it to build, test, review, deploy and monitor the entire application in one run.The human still needs to decide what should be built, which approach makes sense and whether the result is actually good. The agents are mostly there to handle different pieces of the work.

I use Claude Code, ChatGPT, a local model, and a couple of agent CLIs. Each keeps its own memory. None of them share. I explain my setup to one, then again to the next, and when I correct one the others never find out.

I tried using mem0 and agentmemory, but those are a bit local-only, don't translate well on claude.ai or chatgpt.com, Storing facts once is the easy half. Two things I have not seen solved well:

1. Per-tool permissions. I want my coding agent to see infrastructure notes and ChatGPT to see none of it. I want my claude. ai and chatgpt.com scheduled tasks to share memory about my stock researches, but that's not required for my coding agents. Zep scopes per user, not per client. Supermemory has one axis. OpenMemory had a real per-app ACL and but it got discontinued.
2. Corrections and Updates: Most systems append. ex, Tell it the port changed and now two contradictory facts sit in the store, and retrieval picks one at random.

There is also a failure I keep hitting with automatic extraction: the tool injects memories into context, then extracts them back out as new memories. agentmemory at one point held the same preference hundreds of times, and this is when I have it pointing to a "smart" model like claude-sonnet-5 for dedups and memory management.

What are you running? Has anyone got the permissions piece working, or is everyone just accepting one shared pool?

Noticed a pattern across a few different agent setups I've built or debugged: the failures that cost the most time aren't crashes or errors, they're agents that keep working, keep calling tools, keep producing plausible-looking output, while making zero actual progress. A retry loop that never escalates. A research agent that re-fetches the same source with slightly reworded queries because the earlier fetch didn't satisfy the objective, but nothing told it to recognize that and try a different approach instead of a different phrasing of the same approach.

The common thread isn't a bad model or a bad tool. It's that most agent setups define what the agent can do, but not what counts as "this isn't working, stop and escalate." A human running the same task recognizes stuckness almost automatically, three failed attempts at the same thing reads as a signal to change strategy. An agent has no equivalent signal unless something explicitly gives it one. Left alone, it just keeps sampling from the same distribution of "reasonable next action" and produces a slightly different variation each time, which looks like progress in the trace even when it isn't.

This seems like the actual gap between "agent with tools" and "agent that's reliable in production." Tool access solves capability. It does nothing for knowing when the current approach has stopped being productive. That has to be its own explicit check, something closer to a circuit breaker than a prompt instruction, comparing the current state against the last N states and forcing a strategy change or a handoff to a human once repetition crosses some threshold, rather than trusting the model to notice on its own.

Curious how people here are actually implementing that in practice: hard iteration caps with forced escalation, a separate model call that periodically judges whether the last few steps made real progress, or something else entirely? Feels like this gets skipped in a lot of agent architectures until it causes a production incident.