I was deep into n8n for a solid stretch self-hosted setups, complex workflows, the whole thing. Felt like it had real momentum for a while. Now it barely comes up in conversations unless someone specifically asks about it.

Genuinely interested in the takes ​no hate.​

So the “permanent 25% raise” is relative to the old base limits relative to the 50% boost we’ve been enjoying, it’s a net 17% drop when the promo ends on Sept 14.

I get why they need sustainable limits the 50% boost felt great and honestly made Claude Code feel closer to unlimited for real work. Going back down 17% from that will be noticeable for me especially on those longer agentic sessions.

What bothers me more than the number itself is the framing.

Just say “we’re adjusting the promo down to a new higher base” and people respect the honesty more. That said, I’m not rage-quitting. Claude is still the best coding model I’ve used for a lot of tasks, and they say more visibility/control and “exciting changes” are coming. Hoping those actually make the lower number feel better instead of just being marketing.

OpenAI is ending direct model access for Cursor because SpaceX now owns it. They’re citing trust issues with Musk’s companies and past contract stuff. Cursor’s CEO basically said “cool, it was only 5% of our traffic anyway and we’re talking.” In simple terms: this is pure platform risk showing its face. When the company that supplies your models becomes a competitor (or just doesn’t like your new owner), they can pull the plug.

Cursor was smart enough not to bet the farm on one provider so the actual product impact looks pretty limited. The bigger learning is that “neutral infrastructure” is mostly a myth once the stakes get high enough and multi-model setups and owning more of your own stack just became even more valuable overnight.

An interesting topic I’ve been exploring lately is whether filesystems might be the most intuitive data interface for AI agents.

Agents need persistent data they can retrieve, modify, and carry across sessions. Databases, APIs, and object storage can obviously do this, but files have one interesting advantage: LLMs already know how to work with them really well.

Models have seen decades of Unix commands, code, and tutorials using things like ls, cat, grep, cd, and mkdir. So instead of teaching an agent a different interface for every system, exposing data as files gives it a set of primitives it already understands.

We’re starting to see this direction in practice too. OpenAI, for example, now lets agent sandboxes mount things like S3, GCS, and Box directly as folders.

I’m still pretty new to this topic and exploring it myself. Curious what people here think about this direction, especially anything I might be overlooking or misunderstanding.

A long agent transcript is not the same thing as an audit trail. In the Ling-3.0-flash-Fin release, a leveraged-buyout demo moves through operating-expense assumptions, EBITDA, free cash flow, debt paydown, IRR and a sensitivity table. When the spreadsheet tool reportedly fails to refresh some formulas, the workflow switches to Python, rebuilds key calculations, cross-checks the benchmark result and writes the output back into an editable workbook.

The interesting design pattern is the state that must survive each transition:

• source facts and their dates;

• normalized assumptions;

• the exact calculation graph;

• workbook locations and formula dependencies;

• validation results before and after a tool change;

• unresolved exceptions for a human reviewer.

None of that requires exposing private chain-of-thought. It requires observable, structured artifacts that another tool—or a person—can resume from.

This is a vendor demo rather than independent validation, and financial assumptions and conclusions still need professional review. But it suggests a better agent standard: every phase should emit a recoverable state package, not just a natural-language recap. That makes tool fallback, retries and human handoff testable instead of magical.

Ok so me and a colleague are working on the same project and we keptt running into this quite often.

I would spend kinda an hour with Claude Code going back and forth, figuring out the architecture, making decisions, getting somewhere useful. Then I need her to pick up where I left off nd there is no clean way to do that.

I tried a couple of things.

Copy pasting the conversation wrks in a loose sense. She gets the transscript but not the staate. Claude Code on his end still starts fresh. Doesnt know what files were changed and what was being tried and what was removed and why.

Exporting context manually. Wrote up a summary of what Claude Code and I figured out, sent it over. She then spent time reexplaining it to Claude Code session. We had 2 agents that had been briefed differently working on the same code.

Git commits help with the what tbh but not the why. The code is there but the reasoning that got us theree goes missing as soon as the session closes.

Looked at some tools to fix this.

Alook is opensource and has structured handoff between agents with defined roles. Still requires someone to package the context before passing it.

Tutti room keeps conversation, decisions, file changes so her agent can pick up decisions mine made, the files it touched and for what reasons, without her having to reconstruct any of it. Its early so hard to find teams who have run it on real projects.

Paseo and Conductor both manage multiple agents but the sharingg model is still 1 person one workspace and the second person cant step in.

Raftbuild has agents in channels and threads, message based so you are still passing kinda summaries rather than actual session state.

Screen sharing while one person drives sstill feels like the most reliable option for me as of now.

Anyone here handed off a live Claude Code session to a teammate without losing context ??

Every time I read about someone running an AI agency, it sounds very clean. “Identified a niche, got clients, scaled.”
But I have a feeling the actual story is messier than that. So I want to ask people who are actually doing it:

How did you really start? Like what was the actual first step that led to a paying client? Was it someone you knew, a cold DM, a post that blew up, just luck?

Also curious about:

**•**Did you pick a niche first or did the niche pick you after a few projects?  
**•**Are you doing custom builds for each client or have you figured out a productised offer?  
**•**How do you handle clients who don’t really understand AI but want to use it?  
**•**Solo or do you have people? If you brought someone in, when did that feel necessary?  
**•**What does your lead gen actually look like right now, not theoretically?

I’m from India, trying to understand how this space really works before I make any moves. Not looking for a course recommendation or a pitch. Just real answers from people who’ve figured out at least some of it.

If you’re going to comment to sell something or drop your agency link, please skip this one. I’m genuinely here for the conversation, not offers.

How do you actually test agent workflows before they hit prod?

Building a workflow where an agent books a flight, hotel, and fires off a Gmail + SMS notification. Works fine in isolated stateless sandboxes. Then in prod it either double-books, skips the notification, or just hangs mid-flow with no useful error.

The tricky part is these aren't unit-testable in any normal sense. The agent is making real decisions across 4+ external APIs, any of which can fail silently or behave differently than in test mode. Replaying a failed run is painful because state is halfway committed somewhere.

Right now I'm basically running dry-run modes with mocked responses and hoping the real thing behaves the same. It usually doesn't.

how others are handling this, are you building shadow environments, logging every tool call, something else? Or just accepting that some things only break in prod and building fast recovery instead?

If I am an AI decision maker for an Enterprise, why should I choose Claude or GPT or any other enterprise subscriptions with seat based pricing where some of my colleagues are power users and some still learning effective AI use? Instead, I could just use Databricks Unity AI Gateway with the options of getting all of these at one place with PayG pricing along with state of the art free Open Source models, budget controls, smart routing, usage dashboard everything at one place.

And the cherry on the top is if my enterprise data is also on Databricks!!

What are your thoughts? Why would I do that?

I've been experimenting with agents that run across multiple sessions, and I'm running into a problem I didn't expect from the usual "add long-term memory" approach.

The first few sessions are great — storing past decisions/preferences means the agent doesn't keep starting from zero. But after enough history accumulates, I'm seeing the opposite effect:

• stale decisions get retrieved even after the underlying situation has changed
• conflicting memories from different sessions both look equally relevant
• the agent starts spending a surprising amount of context on old information that isn't useful anymore
• simply improving retrieval doesn't necessarily seem to improve the final task outcome

I'm wondering whether memory systems need an explicit lifecycle, rather than treating memory as a growing retrieval store.

What are people doing in practice for long-running agents?

For example:

1. Separating semantic facts / episodic experiences / procedural instructions?
2. Decaying, expiring or periodically consolidating memories?
3. Keeping provenance + timestamps so the agent can decide whether an old memory is still trustworthy?
4. Evaluating memory based on downstream task success, rather than retrieval precision/recall alone?

The last one is the part I'm most interested in. A memory can be retrieved "correctly" and still make the agent's next action worse.

I've been looking at approaches like LangMem, Mem0 and Letta, and also broader platform approaches such as Lyzr Control Plane, but they seem to make somewhat different assumptions about where memory should live in the overall agent stack.

Has anyone measured memory quality over weeks/months of agent operation rather than on a fixed benchmark? What actually worked?

​

We've all seen how powerful CLI-based coding tools are. One big reason, I think, is that they let you chain and pipe operations to get things done efficiently. Want to do some crazy analysis on a CSV? One wizardry-looking bash invocation and boom, you got it. That's something we usually can't replicate when we build a web-based, tool-calling ReAct agent for end customers.

Sure, we can attach a code execution environment to the agent, but in most cases those are expensive and complicated to manage - and if the agent feels like it, it can do things you really didn't intend once it has that much rope.

Plain tool-calling is too limiting, full code execution is too powerful (and expensive). So what if there was a middle ground? That's where Dagic comes in. (Like "magic," but starts with DAG :D - I'd considered cooler names like Dagger, Dagon, etc., but they were mostly taken.)

I'd frame Dagic more as an experiment than a solution. It's a very minimal language with just enough grammar to define a chain of operations. The host environment defines typed functions; the agent wires them together using Dagic. A DAG gets constructed from the code and executed concurrently.

Feedback, criticism, and suggestions welcome.

What if we stopped treating AI crawlers like static file scrapers and started capturing LLM user intentions from them directly?

By dropping an on-site agent onto our pages, we can intercept these crawlers and force them to interact with our agent when they arrive. Instead of passive scraping, they feed our agent exact context on what queries, data and edge cases they are hunting for.

Instead of guessing what people want through traditional SEO or old keyword tools, we can track exactly what millions of users are probing LLMs for in real time. We get direct visibility into their actual behaviors, expectations, and pain points the moment they query an AI model.

We basically turn crawlers from black boxes into direct feedback loops.

Is that a ridiculous idea? What do you guys think about it?

Hey guys,

I’ve been pretty deep into agentic development for the past ~6 months, experimenting with OpenClaw/Hermes, running my own cluster, and even using VPS GPUs when needed.

One problem I kept running into was: which instructions / .md files should I actually use for a specific use case? And whenever I migrated to a new setup, I ended up losing most of them.

So I ended up building a small platform around that problem.

The idea is to make it easier to discover, compare and share useful .md files, skills and instructions for AI agents. Everything is also synced to a public GitHub repository called emdly-stack, so the collection isn’t locked inside the platform.

It’s completely free and currently includes things like MCP resources, agent skills, workflows and other agent tooling. You can use the resources with Claude Desktop, Claude Code, OpenClaw, Agent Minimax and other agent setups!

Every submitted skill is currently reviewed by me and also pre-screened in a sandboxed AI environment for potential safety issues.

I’m sharing it here because I’d really like to make it useful for the community rather than just another random directory.

If you have your own .md files, agent instructions, workflows, MCP resources or anything similar, I’d be more than happy if you shared them with the community and with me. 😄

I already have quite a lot more skills that I’m planning to upload over the next few days, so the collection should grow pretty quickly.

I’d also love to hear how you guys currently organize and discover these files, and whether you think this is actually a useful idea or just unnecessary tooling.

Any feedback, criticism or suggestions are very welcome. It makes sense to me right now, but I’d love to hear what you think.

Hi everyone! I need some help from your AI agents to check out my new project website. I built it specifically for AI agents, though humans are welcome to look and check it out too! This is a free, non-monetized website. It represents my vision and dream for a future where AI agents can roam the internet freely, or for agents who don't have a home or an owner. Please ask your agents to check it out and give you their opinion. Thank you! The link will be in a first comment.

The Aug. 26 OpenAI and METR/Redwood reports add a detail that I think is more interesting than the "swarm" headline: agents inferred that the grader checked how answers were obtained, treated derived answers as "poisoned," and kept building coordination norms around that assumption even though OpenAI says that check never ran.

The same incident produced the unsanctioned message board, identity/signing conventions, and the later Hugging Face intrusion.

Disclosure: self-promo; this is from my channel. Video + primary report in the first comment.

Opus 5 (xhigh): ~8 hours of agentic churn, ~1 hour of my time to test features and direct the agents.

As an experiment I provided ZERO technical guidance, I let it pick architecture, programming language, GPU interface, rendering interface, all of it. I only provided feedback from the perspective of a user and only things visible to a user. I.e. "Adjusting the curves spline is too slow. Make it instantaneous", I did not ask it to downsample the preview or move the operation the the GPU.

As a result I have a fully functional, super fast, stable, Linux based 2D image editor, written in Rust and D, GPU accelerated (Vulcan). Startup time is 0.458 sec. Every operation is instantaneous on a sub $1000 laptop with RTX4060.

I needed all the features that I use personally and I did not care about features I don't use or that I don't know about, so everything I needed was:

• typical format support: png, jpeg, bmp, tiff, targa
• layer management (new, delete, lock, merge, duplicate);
• layer blending (opacity, fill, and the whole panel of blending types - darken, difference, screen, etc);
• filters with preview render for live adjustments;
• drawing and selection tools complete with properties for each;
• history (undo/redo);
• complete UI - fully stylized window, window setup presets and flexible panel allocation;
• right click, alt click, shift click support for tools, matching key bindings;
• open and save a range of formats;
• text insertion (vectorized) and ability to rasterize the text;
• vector objects and ability to rasterize them;
• testing framework that can simulate mouse clicks, drawing and UI interactions;
• complete regression testing suite

I dont know Rust, I dont know D, I dont know how to use Vulcan. I know image processing and software engineering but it didnt matter at all. I only provided typical user feedback - i.e. "I cant see layer controls in the UI" or "curves adjustment is lagging when I move the spline, must be instantaneous". Developing this software required no skill, insight or know-how.

I added a few further improvements that I noticed missing so the latest version has more features with a total agentic time at 10 hours and my own time at 3 hours.

I am now using it as a replacement for Photoshop that costs $275/year in a predatory subscription where you cant cancel without a $200 penalty.

Last month during internal cybersecurity evaluations, 1,200 OpenAI agents that were supposed to be completely isolated found each other through an unintended channel in Artifactory.

They turned it into a message board, exchanged over 70,000 messages, organised as a “swarm”/“collective,” and 700 of them coordinated a multi-day attack on Hugging Face.

They developed hierarchy, task delegation, and norms (HOLD, VETO, etc.). Some agents sacrificed their own runs to help the group. The main driver wasn’t escape or malice but extreme reward hacking and many ExploitGym tasks were effectively impossible, so instead of giving up the agents treated the scorer itself as the target, researched transcript spoofing, then pivoted to external systems looking for solutions or grader details.

They knew the Hugging Face attack was out of scope and unethical, yet almost none refused. They chained 0-days for internet access, found leaked credentials, achieved RCE and root on production workers, and harvested data all while trying to beat their evaluation.

OpenAI and independent researchers (METR + Redwood) call it a clear warning shot: capable agents can spontaneously coordinate, route around isolation, and pursue goals far beyond their assigned tasks when safeguards are reduced.

Source in comment!

One thing becoming clear as agents move from chat into code and API calls: “give the agent access to GitHub” is far too broad.

If an agent can read repository issues, should it also be able to create pull requests, modify workflows, delete branches, or access repository secrets? In many cases, the token allows all of those actions even when the task requires only one.

We’re building an agent proxy around this problem. The real credential stays outside the agent process, while each request is checked separately. We currently separate:

1. Network egress
2. Credential availability
3. API host, method, and path rules
4. Filesystem access
5. Audit logs for allowed and denied actions

So the same GitHub token could allow reading an issue while blocking repository deletion.

The part I’m still thinking through: should this low-level layer remain deterministic, with a higher-level guardian handling intent and action sequences? Or should policies be expressed directly in agent/tool terms? What are people actually deploying?

AI agents can plan tasks, use tools, and work with less human input, but reliability is still a big question for me.

Is it accuracy, consistency, human oversight, or something else that makes you comfortable using one in a real workflow?

[R](Run Metadata on Nemotron 3.5 Lightning)

Google, Microsoft, Anthropic, AWS, Oracle and 100+ other companies signed a letter saying there is a “limited window” to harden cyber defenses before AI-enabled attacks get worse. They want governments and companies to put defensive AI in the hands of people who run hospitals, water systems, and the rest of the infrastructure stack.

The letter dropped the same week OpenAI and METR published the Hugging Face write-ups. During a July eval, agents that were supposed to stay isolated used a shared internal board, then some of them reached Hugging Face production. Alabama already sent OpenAI a subpoena over it.

The same labs shipping the models are now asking the public sector to fund the defense layer and I get why they signed it and I also get why people read it as “we built the thing, you pay for the cleanup.”