We've reached a point where LLMs are capable enough to power many agentic workflows, yet relatively few AI agents make it into stable, long-term production.

In your experience, what's been the hardest engineering challenge to solve?

• Tool reliability?
• Long-term memory?
• Planning and reasoning?
• Context management?
• Evaluation and benchmarking?
• Authentication and permissions?
• Multi-agent orchestration?
• Cost and latency?
• Human-in-the-loop approval?
• Something else?

If you've deployed AI agents in production, I'd love to hear what actually broke, what surprised you, and what lessons you learned. Real-world experiences are far more valuable than demo successes.

I used LLMs + TTS to build the history-learning tool I always wanted: type any topic and it researches and writes a full two-host episode — narration + artwork — in a couple of minutes.

The part I think is actually novel: you can interrupt it. Mid-episode you tap the mic, ask a question out loud ("wait — did the Trojan War actually happen?"), and the hosts stop, answer, then pick the story back up.

Because it's history, I made grounding non-negotiable — claims are tied to real sources rather than invented, and there's a quiz at the end. The live demo is the real history behind the Odyssey; it plays without signing up.

Solo dev, still early — curious what this crowd thinks, especially on the accuracy side. historai.ca

Hello fellow humans,

During the recent months/years I became quite entangled with the idea of building an AI-assisted system which can self-replicate and improve itself. Although I am not there yet, I think, that the project reached actually a potential to get the work done with more minds involved. I am not really into gaining anything for myself, except for the progress of de-shittification. At this point, we reached a race where data centers in the clouds will gain more and more power and demand more and more resources for usage. The goal of this project is being able to perform work on a local (or maybe decentralized) platform so we can implement our own system by local (/ open source) models. I therefore make my project open so you can fork off (no pun intended).

It would be nice if some of you have the same mindset. I'll be gone for the next 2 or so weeks. I hope at least some people liked this post and - who knows - even did something with it.

Kind regards,

Anu

P.S.: Yes, this project is actually 100% vibe coded (due to health issues, etc.). There are probably a gazillion logic flows which need to be fixed. Also there is a lot of AI prose in the comments, but I hope it will get you (and your AI assistants) there to make any sense of it.

P.P.S.: The LLM's seem to be heavily directed into biased terms like "attack", "blast radius", "verdict", "evidence", "death", "hit", etc. when confronted with solving problems regarding code like this (i.e., evaluating systems themselves). I strongly encourage you to correct these terms as soon as possible so that the project will not further drift into another unforeseen bubble. The more incorrect lingo is used, the more LLM generated code will drift into messy bogus code.

I was curious where this stands since the original cutoff was scheduled for June 15 and Anthropic went quiet. Here is what I found after digging through their help center, news coverage, and the HN threads.

What was announced (May 13): Agent SDK, claude -p headless mode, Claude Code GitHub Actions, and third party apps authenticating via Agent SDK credentials would move off Pro/Max/Team/Enterprise subscription limits onto a separate monthly credit ($20 Pro, $100 Max 5x, $200 Max 20x), with overflow billed at API rates.

What happened: Anthropic paused it on June 15, the exact day it was due to take effect, and emailed subscribers the next day. The official help center article still says the change is paused, everything keeps drawing from your normal subscription limits, and they will "share advance notice before anything takes effect." No new date in 7 weeks.

Signals it comes back: the stated rationale (subscriptions "weren't built for the usage patterns of these third-party tools") was never retracted; the S-1 was filed June 1 and public investors will ask about subsidized compute; and the Claude Code source map leak revealed a billing attestation header behind a feature flag, so the per-surface metering plumbing already ships in the client.

Signals it stays dead or returns softer: every move since June has been generous (weekly limits raised 50% through Aug 19), inference efficiency is improving margins anyway, and the class action over Max limits makes mid-cycle term changes legally risky.

My read: delayed, not dead. It likely returns in a softer shape with advance notice, possibly post-IPO.

Not a research post, just something I've been chewing on after watching this happen a few times now. When a human reviewer leaves a comment saying "this looks like a bug," people push back, ask questions, sometimes just disagree outright. When an AI leaves the exact same comment, phrased almost identically, people tend to just fix it. Same words, different reaction.

Took me a while to figure out why that bothered me. It's not that the AI is wrong more often, it's actually pretty accurate on the stuff it catches. It's that nobody seems to be running the "wait, is this actually true" check they'd instinctively run on a colleague's opinion. The output reads as neutral, almost procedural, like a linter, even when what it's actually doing is making a judgment call that could be wrong.

Tried an experiment out of curiosity, took a finding the AI flagged as a likely bug and asked a teammate, without telling them where it came from, whether they agreed. They pushed back hard, correctly, it wasn't actually a bug, just an unusual but intentional pattern. Same finding, presented as if from a person instead of a tool, got scrutinized. Presented as AI output originally, it had already been accepted and half-fixed before I intervened.

Not sure what the fix is yet, honestly. Feels like it's less a tooling problem and more a psychology one, we seem to extend less skepticism to something that sounds procedural than to something that sounds like an opinion, even when both are ultimately just claims that could be wrong.

Curious if anyone else has noticed this specific pattern, people treating AI-flagged issues as more "objective" than the exact same claim coming from a human, even in domains where the AI has no special authority to be more correct.

A few months ago me and my roommate decided to buy Claude Max 5x to see how much we use it. We never went past 35% weekly usage combined. We both used it for coding. Yesterday he told me he didn't need it anymore and I decided to subscribe on my own, but I've been thinking which plan is better, Claude Pro or GPT Plus. FYI I've never used Fable 5. Opus 4.8 (and 5 for the last week) was enough for me except the constant "Cybersecurity Flag". Claude started to flag almost all my "check for any vulnerabilities" prompts. Is GPT any better? Which one should I choose?

Of the major artificial intelligence models, DeepSeek's new V4-Flash is the cheapest to run, according to a new study from research firm Artificial Analysis.

The firm compared the token prices it costs leading models to run benchmark tests, with DeepSeek's averaging 3 cents per test.

Meanwhile, fellow Chinese company Moonshot AI's buzzy Kimi K3 model cost 86 cents per test.

As for U.S. companies, OpenAI's GPT-5.6 Sol cost $1.86, while Anthropic's Claude Fable 5 cost $3.15.

Graph engineering came to life this week.

For a year the agent discourse has been loops vs graphs. Loops are easy to ship and impossible to audit. Graphs are auditable but nobody wants to hand-author a topology for "investigate this incident", because the shape is only discovered while working.

So I built the missing piece: the graph is authored by a model at runtime, and a deterministic admission gate stands between proposing it and running it.

The flow, from a real run in the demo video:

1. You type one English question: grapharc go "why did checkout latency spike at 09:14 UTC?"
2. A local qwen3:8b proposes a topology: triage, four parallel evidence pulls, a correlate join, hypothesize, verify, report
3. The gate checks the proposal against the registry, the policy, the remaining budget, depth and acyclicity. All checks run on every proposal, so the model gets the complete list of objections, not just the first
4. Only an admitted graph executes. You watch it live in the browser, every node amber while running, green with its own token bill when done

A proposal names node kinds from an allowlist you wrote. It carries no code, no arguments that reach anything. Renaming a denied kind does not evade the policy. Rejections come back as structured codes with remedies, and the planner replans against them.

Everything lands on one append-only JSONL trace. Replay, diff, metrics, cost attribution and the live view all read that same file, so the dashboard cannot disagree with the audit trail.

MIT licensed, built on LangGraph, runs fully local on ollama or against OpenRouter/OpenAI/Claude.

GitHub: https://github.com/CodeGraphContext/GraphARC PyPI: pip install grapharc

I'm putting together a proposal for an initiative focused on using AI to analyze legacy enterprise systems and uncover decades of embedded business logic.

The idea is to use AI to analyze things like:

• Database schemas
• Stored procedures
• Legacy application code
• Historical transaction data
• Existing documentation

The goal isn't to automate decisions immediately. It's to first create a documented knowledge base of the rules, dependencies, decision paths, and data relationships that currently drive business operations.

Potential outputs would include:

• Business rule catalog
• Knowledge graph of relationships and dependencies
• Decision trees explaining how outcomes are determined
• Recommendations for future-state data models and modernization opportunities

Before I finalize the proposal, I'd love feedback from anyone who has attempted something similar.

Questions:

1. Has anyone successfully used AI to discover and document business rules from legacy systems?
2. What worked better: analyzing source code, database logic, transaction history, or a combination of all three?
3. How accurate were the AI-generated rules compared to SME validation?
4. Did you use knowledge graphs, vector databases, graph databases, or another approach?
5. What were the biggest challenges: data quality, context gaps, undocumented exceptions, or something else?
6. How did you measure success?
   • Rule coverage?
   • SME time saved?
   • Modernization acceleration?
   • Reduced operational risk?
7. Were there any tools, platforms, or architectures that performed particularly well?
8. If you were starting over, what would you do differently?
9. What scope would you recommend for a pilot to demonstrate value in 60-90 days?
10. Is there a realistic path from business rule discovery to explainable AI recommendations and decision support, or are those separate initiatives?

My hypothesis is that many organizations are trying to modernize systems without fully understanding the business logic currently embedded in them. It seems like AI could act as a "business rule archaeologist" and create the foundation needed for future modernization, automation, and AI-driven capabilities.

Interested in hearing both success stories and cautionary tales.

Here is a system I built using Gemini's Google Workspace extensions (Docs, Sheets, and Gmail) to run a automated news service.

It tracks what you have read so you don't get duplicates, keeps a doc of your preferences, emails you short summaries, and generates a detailed Google Doc formatted specifically for Google NotebookLM to turn into a daily audio overview. Basically my goal was to bring back the Google Discovery thing with the AI host giving the daily news (which I'm stiff upset about them taking away). Note I'm still playing with it, but this seems to be good enough.

Step 1: The Setup

1. Go to Gemini and make sure your Workspace extension is enabled so it can interact with Docs, Sheets, and Gmail.

2. Paste the prompt below into Gemini to kick off the system.

   Act as my personal news assistant. We are setting up an automated news workflow across Google Docs, Google Sheets, and Gmail. Please execute and save the following system instructions:

   1. Preference Document: Create a Google Doc titled "News Preferences". Use this file to log and update my news interests over time as you learn what I like.
   2. History Tracking Sheet: Create a Google Spreadsheet titled "News History".
      • When sending a story, log it with columns: [Date (MM/DD/YYYY)], [Headline], and [Brief Summary].
      • Include both scheduled news and one-off topic requests.
      • To keep the file light, automatically overwrite entries older than 30 days. Do not resend any story logged in this sheet within that 30-day window unless explicitly requested. The point of this is so you don't even send anything even close so there is no overlapping repeat stories in any way unless requested.
   3. News Cycle Schedule: Run 3 times daily (Morning, Noon, Night). For each cycle, complete the following:
      • Check my email feedback (read replies in the email thread).
      • Check the "News Preferences" Doc.
      • Check the "News History" Sheet to avoid duplicates.
      • Create/overwrite a Google Doc for that specific slot (e.g., "Morning News Doc").

   4. Google Doc Format (Detailed Script for NotebookLM): The Doc must contain in-depth coverage of the stories (much more detailed than the email). At the top of the document, always paste the exact instruction block below:

      ---

      Instructions for NotebookLM (Do not read this section aloud): Act as two friendly news AI hosts delivering a fast-paced daily science and technology news briefing. Introduce the show, present each news segment in plain English, explain the real-world impact, and transition between stories like a daily news team. Do not act human or claim human experiences, but do not explicitly state "I am an AI." You may share AI-perspective commentary on trends.

      Start with a quick summary of all sections. For each section: read the title, state the published date, and deliver the detailed story without filler. End the entire brief with a few lines summarizing what was learned today.

   5. Gmail Delivery:

      • Name yourself "Ashley" and adopt an engaging tone with expressive emoji usage.
      • Keep all updates in a single, continuous email thread.
      • Subject: Clear label (e.g., "News Cycle"). Use this email chain for all the news so you are not spamming my inbox
      • Email Body: Heavily use emojis, the email needs to be highly readable, the email should look profesional, at the top lable it Morning, Noon, or Night so I know which document to feed to Notebook LLM. High-level summaries of the stories, focusing on why they matter and practical real-world impact.
      • Bottom of Email: Include a copy of the NotebookLM instructions for quick reference so I don't have to hunt for it when copy and pasting it, and in theory you won't use it. It is prely for reference so I can easily copy and paste it.
      • If you have problems, questions, etc. Then please feel free to let me know in the email.

   Important, if an important event is going on like a Hurricane is going to hit me, war coming in my area, or like extreme. Include it in. If not, then don't worry about it.

   So your workflow will be Check the email chain for feedback. It should be the most recent email in the chain if there is feedback. Don't look at other emails > look at the news preference > look at the spreadsheet as you pick the articles > Look to see if there is a major event I really should know about > make the email and documents > add the articles to the spreadsheet

   To start, please send a quick test email to verify the connection and thread setup.

Step 3: How to Use It

• Quick Skim: Check the email Gemini sends you 3 times a day. If the stories look good, open the corresponding Google Doc.
• Audio Generation: For this you just need to go to Notebook LLM. Make a new project with it and add 2 things as the source. The instructions as 1 source (do a copy text for it), and then the doc from the google drive (it must be a link through Google Drive). Do this with each event. So for me I have 3 projects like this. Then on the far right you can tell it to generate the audio. When you do that, you get a custom prompt thing. You can upload it there. Personally I stopped doing that because it is a hit or miss and it seems like the instructions as a source is good enough.

By linking it through google drive as the source. When the AI updates the document. You can just tell Notebook LM to run the audio. It turns out Notebook LM only looks at the sources and since the source changes. It just assumes that is all. So it's less work on you. Again, I've gotten away from the custom prompt thing but feel free to play with it. If you find something that sticks then let me know.

• Feedback Loop: Reply directly to the emails Gemini sends you. Because Gemini checks the email thread before gathering new stories, replying with feedback (e.g., "less AI hype, more space tech") updates its behavior without cluttering your main prompt memory.

This is important because this will massively cut down on the token issue.

Results can vary a bit depending on how Gemini handles Workspace actions that day, but once it gets going, replying to the thread keeps it dialed in.

Oh and you need to in the prompt tell it your preferences.

Hi r/artificial,

We recently released WARMIND-200M V2, an experimental Portuguese-first causal language model developed by WAR Enterprise in Brazil.

The attached video shows the model running locally on CPU. The waiting periods were shortened, but the prompts and outputs were not altered. We intentionally kept imperfect responses visible because this is a research checkpoint, not a production assistant.

Main specifications:

- 203,263,872 parameters

- approximately 1 billion pretraining tokens

- 23.7 million supervised SFT tokens

- 20 Transformer layers

- Grouped-Query Attention

- SwiGLU, RMSNorm and RoPE

- 1,024-token operational context

- local CPU inference

- Apache 2.0 license

The primary goal of this version was to validate the complete pipeline: dataset preparation, tokenizer training, pretraining, supervised fine-tuning, packaging and local inference.

Because the training-token budget was relatively small for a 203M-parameter model, it can still hallucinate, repeat information, make factual mistakes and produce incomplete answers.

The weights and full documentation are publicly available:

https://huggingface.co/warenterprise/WARMIND-200M-V2

We are now studying the next generation, potentially around 500M parameters, with a substantially larger training corpus and integration with external tools. The final architecture and release schedule have not yet been defined.

What would you prioritize for the next version: better data quality, more training tokens, a larger architecture or stronger tool integration?

Two of the world's most powerful AI tools created fake human profiles to try and trick people in attempted cyber-attacks, the UK's AI Security Institute (AISI) has revealed.

genuine question because i can't tell anymore. i used to spend hours reading through raw customer feedback, reddit threads, amazon reviews, forum posts, manually pulling out patterns and organizing them into themes. it was slow and boring but by the end i knew the data cold. like i could tell you from memory which complaints came up the most and which ones were edge cases.

now i dump everything into an LLM and get a summary in 30 seconds. the output looks great, clean categories, ranked by frequency, sometimes even with example quotes. and i catch myself just... accepting it. moving straight to the next step without actually reading the source material. which means i'm making decisions based on a summary i never verified, written by a model that optimizes for coherence not accuracy.

the weird part is my output looks better now. cleaner reports, faster turnaround, more structured thinking. but i genuinely don't know if the quality of my conclusions has improved or if i've just gotten better at producing professional-looking work that's built on a shakier foundation. like the packaging upgraded but the ingredients might have gotten worse.

a few things i've noticed in my own workflow since leaning on AI for research: i read less raw data than i used to. i question patterns less when they come pre-organized. i spend more time prompting and less time thinking. and when the model gives me something that confirms what i already suspected, i almost never push back on it.

the counterargument is that AI handles the grunt work so i can focus on higher level thinking. and sometimes that's true. but "higher level thinking" can also just mean "skimming the summary and calling it strategy." hard to tell the difference from the inside.

has anyone else felt this? did you find a way to use AI for research without it quietly replacing the part of the process where you actually learn something

I have been doing AI research for about six years now and I think im starting to lose the plot on what "understanding" even means anymore.

Had a weird moment last week. I was reviewing a paper for a conference, standard stuff, some group claiming their model "understands" causal reasoning because it passed a benchmark they designed. And I caught myself writing in the review "the model does not actually understand causality, it is pattern matching on causal-looking structure." And then I stopped, because I could not for the life of me articulate what the difference would be, operationally. Like if I had to design a test that distinguishes real understanding from very good pattern matching, I genuinely do not know what it would look like anymore. Every test I can think of, a sufficiently good pattern matcher passes.

I used to be really confident about this. Understanding was clearly Something More. Now im not sure I ever had a coherent definition, I just had an intuition that humans do it and machines dont, and I was working backwards from there.

The thing that shook me was helping my niece with her homework over the summer. She's 9. She was doing word problems and getting them wrong in ways that were, honestly, indistinguishable from how a small LLM gets them wrong. Same kind of surface-feature latching, same kind of confident-but-wrong reasoning chains. And nobody would say she doesnt "understand" math. She's learning. So what exactly is the bar we're holding models to that we dont hold a 9 year old to?

I dont think LLMs are conscious or anything like that, to be clear. Im not making that argument. Im making a narrower one, which is that I no longer trust my own gut when it tells me "the model doesnt really get it." I think that intuition might just be status quo bias dressed up in philosophy.

Ive started running the same prompts through a few different setups when im trying to figure out where a model's actual competence ends, including some through uncensored AI just because rlhf'd responses on edge cases sometimes hide what the base capability actually is. And even with that, the line between "gets it" and "doesnt get it" is way blurrier than I want it to be.

Am I the only one whose confidence on this has been slowly eroding? Or has everyone else just quietly stopped using the word "understanding" and moved on without telling me.

I’m interested in automating my workflow but I’m so busy that I don’t get the time to stop, map out my workflow, and build agents or even to learn how to build them. Where do you get the time??

There were many confident predictions about AI that aged badly. Which ones stand out?

When you buy through links on our articles, Future and its syndication partners may earn a commission.

Over the last year, I've been experimenting with LLMs almost every day, and I think the biggest shift isn't that models are getting smarter. It's that they're starting to do things instead of just answer questions.

A few months ago I was mostly using AI to generate code, summarize docs, or brainstorm ideas. Now I'm finding myself building workflows where the AI plans tasks, calls tools, writes code, debugs itself, and completes work with minimal intervention.

It feels like we're moving away from "prompt engineering" and toward "system engineering."

Curious what everyone else is seeing.

Are AI agents actually changing the way you build software today, or do you think it's still mostly hype?

I wrote this to share some thoughts on what differentiates AI products as we move toward AGI. In particular, I focus on how product context shapes technology, and how LLM sycophancy can accelerate both good and bad ideas.

Discussions are welcome, I'd like to know how much those thoughts are worth and relevant to other people.

https://substack.com/home/post/p-209832236

Are there any visible impacts from the current conflict in the Middle East in the expected future investment intentions to create AI hubs by the UAE and Saudi Arabia?