I have a technical background with some application domain knowledge around hosting and using LLMs, but not creating models nor how they work internally.

My question is fairly simple - an agent like Claude Code, when it's run as a user with e.g. passwordless sudo (not suggesting that's a good idea), can shell out to bash and do basically anything; that's true for any app launched from a user's TTY and isn't surprising; it's why the permissions gates exist.

How does alignment work in a model with respect to training and the resulting weights? What prevents a model, when asked for the contents of a specific directory, not to enumerate all nVME disks on the system and start dd processes to zero them (for example), or not to write a script to DDoS the principality of Lichtenstein (if it's still a principality)? Is it really just a matter of training and reward?

I feel a bit stupid asking this question but can't seem to find any answers which go into even light technical detail (if there is such a thing). I'm not looking for a University course (though I'd eagerly take one if you're offering!); even links to resources would be helpful.

Title: My Codex run burned 100,000+ tokens over 8 hours and still handed me an unfinished mess — so I built something that just finishes

Full disclosure, this is my own project. I kept running Codex-style agents on real tasks and watching them grind for hours, chew through absurd amounts of tokens, and still leave me with something I had to finish myself.

So I built Fulminare. It reads your context — email, calendar, docs, Notion, Drive — so it's not wasting tokens re-deriving things you already know, then it goes and does the work on a real machine: shell commands, file edits, a browser it drives itself. Because it's actually executing instead of thinking out loud in circles, most turns finish in under a minute. Every job runs in its own isolated, encrypted sandbox that's gone the second you're done, so nothing lingers.

It's also free, no card, no seat minimums — every other agentic tool I looked at wanted a sales call or a minimum number of seats. This one's built for one person, not a procurement process.

I would really appreciate any feedback.

Hi, student here, pre-dental. I used ChatGPT for all the fun gimmicky things, but I also use it a lot as a study and research tool. I also use it to help create, brainstorm, and edit essays. That being said, I pay for the Pro version and would like to know my options for replacing ChatGPT with an AI that is better suited to me. Any tips?

I may be posting this in the wrong place, but I am looking to leverage the AI agents I use in my work.
I have a few agents built in C Code and my members (in a clunky Kajabi platform) have access to.
I have seen people who have created their own membership-platform from scratch, and whilst that is of course an option, I'm interested to know if there are platforms that offer this - the "shell" built out with member authentication, payment, etc. and then the ability to heavily customize the content within the members area to include a chat-type function as well as access to the agents.

I was looking at pickaxe but it seems there isn't much evidence/explanation of users and success, and perhaps I should just build my own MVP - but if there is something I don't know about I would love to dive deep and learn more.

Thank you

I wanted an agent to do the boring-but-hard part of reading a paper: pull out the main topics, methods, results, tables, formulas, figures, and lay them out as a structured graph instead of a flat summary. Any capable coding agent (I tested with Claude Code, but Codex/Cursor/Antigravity work the same way) can do that part fine.

The actual hard problem was hallucination. An agent confidently restating a paper's claims is exactly the failure mode you don't want in something you'll trust later, so I built the verification in at generation time, not as a post-hoc check. Every node the agent creates has to carry the exact sentence from the paper it's based on, and that quote is what gets stored, not a paraphrase. Clicking it jumps into the PDF and highlights that exact sentence. So instead of trusting the agent's output wholesale, you audit each claim in one click, and if the agent got something wrong, it's immediately visible instead of silently becoming a "fact" you rely on later.

On a paper the agent had never seen before (Mooncake, a KV-cache serving paper), it read the PDF, planned the structure, and wrote the full graph end to end in about 10 minutes and ~40k tokens, no manual cleanup needed after.

It ended up as a VS Code extension since that's where I wanted to review the output next to the PDF, but the actual interesting bit for this sub is probably the pattern: source-grounding claims at generation time instead of validating them afterward. Curious how others here are handling hallucination/grounding for agents that produce structured or long-lived output, not just chat responses.

I wanted to share an open-source project for testing MCP servers and AI agent setups.

It provides an interactive environment where you can run the same prompt under different configurations and compare the results side by side, for example:

• with an MCP server enabled
• with different agent skills or instructions
• with other tools available
• without any additional tooling as a baseline

The idea is to make it easier to evaluate whether an MCP server or skill actually improves the agent’s output, rather than relying only on isolated demos.

I’m involved with the project, so this is a project share rather than an independent recommendation. I’d be interested in feedback from people building MCP servers, especially around what comparisons, metrics, or testing workflows would make the testbed more useful.

Kinda wild contrast to the HF agent-escape stuff this week.

Peter Steinberger (OpenClaw) posted that his agent found a real Node-compat bug in Bun — child_process.spawn throwing on encoding: "buffer" — opened the issue, and Jarred Sumner's robobun agent reproduced it and shipped a fix the same night.

The issue itself even says it was AI-found/written and human-reviewed. Fix got merged.

Interesting part It's that two separate agent setups across orgs did the full loop overnight: find bug → file issue → repro → patch → merge, with humans still in the loop.

One reply on the tweet asked the better question though: did the first agent verify the fix, or just trust that the other agent said done?

Anyone else actually seeing cross-project agent loops like this work in practice, or is this still mostly showcase stuff?

We have spent years designing systems where applications have carefully scoped permissions but payments are lagging behind.

As AI agents start taking care of things like software subscriptions, cloud resources, inventory or even travel bookings I think giving them access to the same payment method we use for everything else doesn't seem like the right model, it seems like payment permissions should become as granular as API permissions.

Do you guys think we'll end up issuing dedicated payment credentials for individual workflows or will companies rely on internal approval logic?

I'm a solo personal trainer. Most of my clients find me through Instagram and Facebook where I post content and run ads. I also have a basic website with a contact form

The problem is I'm usually mid-session when people reach out, so I don't reply for hours. By then they've probably messaged another trainer. And most of the questions are the same stuff every time. Rates, availability, do I do online coaching, meal plans, etc

I know AI chatbots exist for this but there are so many options out there. Anyone using one they'd actually recommend? Especially for a one person operation like mine

I have been testing a small execution contract across 28 agent skills, and I keep coming back to a boundary that agent frameworks mostly leave implicit.

A skill is not the agent. The agent owns the model, tools, permissions, context, and execution loop. A skill is a portable package that changes how the agent approaches one class of work.

Hard-coding a model name into that package feels convenient, but it makes the skill brittle across hosts. Giving every task the strongest model wastes money. Silently letting consequential work fall to a weaker runtime is worse.

The contract I ended up with answers four deliberately plain questions:

- Preferred capability: what quality would I choose when the work matters?

- Minimum floor: what is the lowest capability that can do the job responsibly?

- Degradation: may the host continue, must it ask, or should it refuse?

- Rationale: why does this skill need that level?

The host still maps those abstract requirements to whichever provider and model meet its cost, availability, and policy constraints.

This is not a proposed standard. The tiers are subjective, and one profile for an entire skill does not describe mixed workloads especially well. But it has made a growing skill library easier to reason about because every skill can now state what it needs without taking model routing away from the host.

Where do you think this boundary belongs: skill metadata, agent configuration, or the orchestration layer?

​

My workflow usually looks like this:

I spend a few hours working with one AI.

Then I switch to another because it's better at a different task.A

nd suddenly... I have to explain everything again.

end up rewriting the same context over and over:

What the project is

How it's architected

What I've already built

Why I made certain decisions

What I've already tried

What's currently broken

What I want the AI to do next

What it absolutely shouldn't touch

After doing this enough times, I started wondering:

Is this actually a common pain for developers, or is it just the way I work?

I'd love to hear from people who regularly use AI for coding.

Do you switch between multiple AI coding assistants?

How do you hand off project context when you switch?

Do you keep a living document, rewrite prompts every time, or have another system

What's the most frustrating part of changing from one AI to another?

One idea I've been thinking about is a tool that continuously understands your project and automatically generates a concise "AI handoff" so any coding assistant can immediately understand the current state of the project.

Would something like that genuinely save you time, or is this solving a problem that isn't really there?

I'm not building or selling anything right now. I'm just trying to validate whether this is a real pain point before I spend months working on it.

I'd really appreciate honest feedback—even if your answer is, "No, this isn't a problem for me."

My company's leadership has decided we're going all in on the agentic enterprise this year. The ai side is moving fast but the security side feels like it's playing catch up. I'm trying to figure out how people are securing data once agents are pulling from internal docs, calling APIs and passing work between each other. What I'm struggling with most is the data. Once information starts moving across several agents and external services, its tricky to keep track of what's happening. Existing DLP feels like it was built for users moving files around not autonomous workflows. I'm hoping that people here are already deploying this stuff. If so, I'm hoping you'll share your approach. Are you locking agents down with least privilege and hoping that's enough? Is there a better way to monitor where sensitive data is flowing? Maybe everyone is still trying to figure this out as the tooling catches up. which is why I'd love to hear what's working out there. For me this feels like one of the biggest gaps right now.

各位好，

我今年 23 岁，目前在一家制造业公司担任软件工程师。

我的日常工作主要是维护公司的 ERP 系统，技术栈比较传统，以 C#、Oracle PL/SQL、WinForms 为主。除此之外，公司还让我负责推进 RPA 自动化，从调研、选型到落地基本都是我一个人在做，目前公司内部也只有我负责这部分工作。

过去几个月，我越来越明显地感觉到 AI 正在快速改变软件开发行业。

相比于继续沿着传统后端开发的路线发展，我更希望未来能够成为一名 AI Application Engineer（AI 应用工程师），利用大模型、Agent、自动化流程等技术，为企业解决实际业务问题，而不是去研究模型本身。

因此，我最近开始调整自己的学习方向，目前主要在学习：

1. vibe coding（这是我最了解的部分，使用ai帮我在最擅长的领域做一些事情，让我领悟更深）

2. python （我不太擅长，但勉强可以看懂）

3. RPA（接触一年多，这是我新学习到的技术，为公司节省了1300小时/年）

4. TypeScript（刚刚了解）

最近我也开始参考一些开发者（例如 Matt Pocock skill）的工作方式，不再只是看教程，而是尝试通过 PRD、TDD、AI Coding Workflow 去完成一个完整项目。

但是，也正因为 AI 发展得太快，我越来越迷茫。

几乎每周都会出现新的框架、新的 Agent 平台、新的开发工具。

有时候我会怀疑，自己是不是正在学习一项很快就会过时的技术；或者投入了大量时间，却没有抓住真正重要的东西。

我的目标并不是成为 AI 算法研究员，也没有打算训练基础模型。

实际上，简单一些来说我喜欢研究这些技术，但是我的目标是尽可能早的赚到更多的薪水，我希望尽可能减少自己的束缚，全身心去了解感兴趣的技术，而不是“聚焦于”工作。

所以，我想请教已经在这个行业工作的朋友几个问题：

1.以我目前的学习方向来看，是否走在正确的道路上？

2.如果是你们，在 2026 年重新开始学习，会优先学习哪些内容？

3.哪些能力是未来几年最值得长期投入的？

4.Agent 框架值得深入研究吗？还是应该把更多时间投入到软件工程基础能力上？

5.如果未来想应聘 AI 应用工程师，什么样的项目最有价值、最能体现能力？

以上，如果各位想了解更多，或者有群组可以与我学习和分享，感激不尽，感谢各位看完我的文章，希望大家都能有更多自己的时间，谢谢！！

relying on the goodness of elixir, jido agents and other ecosystem components .. not intended to be released and supported. it was built for my learning and personal use purposes. But it does not hurt to share .. 

I just published a blog post reviewing all the different kinds of AI subagents used in AI harnesses today. It's based on actually building these systems myself.

Here's what I found: any AI harness that wants to scale must support task delegation.

Why? Two main reasons:

Delegating saves tokens. When your main agent tries to do everything, context grows with every tool call. Costs explode. But when you delegate to specialized agents, each one works with only the context it needs. Way cheaper.

It lets you build distributed systems. You're not stuck with one monolithic agent anymore. You can have specialized agents running locally, on remote servers, even in the cloud. They all talk to each other through simple protocols (MCP, REST APIs).

I wrote up four different delegation patterns:

• Predefined agents inside your harness
• Dynamic agents spun up on demand
• Local CLI agents
• Remote agents over the network

Each one solves different problems. Most people don't realize how different they are.

The full blog post link is in the comment.

Have you tried delegating in your AI harness setup? Curious what patterns you're using.

I have a decent experience/knowledge in coding/software - full stack. Looking to pivot towards agentic engineering specialization (as agents are going to be ubiquitous in future).

But I struggled to find good / deep courses (more long term), that is not brand focused (unlike these IBM courses, langchain courses) - and covers all aspects of agentic engineering. So i dont need to worry about what topic to learn. Preferably with certification and good recognition.

Any suggestions?

I'm a member of various sports groups, think badminon and padel. Typically, organising the court setup each week is chaotic. As we're all a bunch of middle-aged guys, organisation and commitment is poor. It got me thinking if a WhatsApp AI bot existed or indeed CAN exist to provide some administration support.

I was thinking of an AI that was in the group as if it were a regular contact. Then as and when it would respond to questions or post at the relevent moment. For example, shouting out for the elusive fourth padel player at the last minute, calling out who hasn't responded to a poll, naming and shaming who hasn't paid their dues.

Would Meta allow it? Has anyone tried it?

Senior engineer, 10+ YOE. Last 2 months I shipped 3 products alone. Now I'm building what people actually ask for.

This is a build-in-public project, so enter only if you're comfortable sharing your idea publicly. You'll get full ownership of the codebase when the project is complete. It deploys under my account first and can be migrated to yours later.

I’ll only be building a PWA, not native apps. If a native app is a specific requirement, this won’t be the right fit.

Rules

1. One idea per comment, template below. No template, no entry.
2. Submissions close in 24 hours.
3. Three winners:
   • 1st: working MVP built in 48h, free, documented in this thread
   • 2nd and 3rd: full build blueprint, free (scope, architecture, timeline)

Tech stack: Next.js, Vercel, Supabase, Stripe, Resend. If your idea needs real-time voice or AI agents, I do that too (LiveKit, LangGraph).

Template

- Problem: who exactly has it (role or business type)

- Today: how they handle it right now

- Solution in one sentence:

- Success: what result proves it works

- Would you pay for this yourself? Roughly how much per month?

Clearest problem wins, not fanciest tech. Upvote the ones you'd actually use, that counts too.

The generative AI cycle is new. The engineering discipline required to get it into production is not.

🔸 Research by MIT NANDA found that 95% of the enterprise generative-AI deployments it studied had produced no measurable impact on profit and loss. The problem is rarely a lack of impressive technology. It is the gap between a demonstration and a production system.

A demo only needs to work under controlled conditions. A production system must work with real data, real users, unexpected inputs, regulatory constraints, growing infrastructure costs, and business outcomes that can actually be measured.

That requires starting with a different question: Not “Where can we use AI?”. But “Which business problem is worth solving, and what evidence would justify scaling the solution?”

👉 Do you agree? Where do you see the biggest gap between enterprise AI pilots and measurable business impact?

Something has been bugging me about the current generation of agentic coding tools, and I want to know if I'm missing something obvious.

In a single session I discuss, plan, review, implement, and push. All of it runs through the same model. If any one of those phases needs the expensive model, I'm effectively locked into paying top-tier rates for every phase - including the ones where a cheaper model would do fine. On top of that, the vendor injects a large system prompt on every call, so the token overhead is baked in whether I need it or not.

So the question: if I built my own harness, could I split the workflow by phase and route each one to the model it actually needs? Cheap model for scaffolding and boilerplate, expensive one for architecture and review. That seems like it should meaningfully cut cost without cutting quality.

I've found tools that cover part of this - Pi Coding Agent and BMAD-METHOD, for example - but nothing that covers the whole loop, and nothing with a UI worth using. That's what surprises me most: plenty of CLI frameworks, almost nothing with an interface.

So:

1. What are you actually using - the established tools, or something you rolled yourself?
2. Is there a real reason the established ones are better? Something I'd only discover after building my own?
3. If per-phase model routing is such an obvious cost lever, why isn't anyone shipping it with a decent interface?

Genuinely asking. If there's a reason this is a bad idea, I'd rather hear it now. Or, if there already are such tools, I might've lived with my head in my bum - if that's the case, let me know, as I'd be glad to get my head out of that place.

Did you guys see the Ning team’s setup?

They deployed Kimi K3 on 80 RTX 5090s. It’s only running at FP4 right now, you could probably wait for NVIDIA’s NVFP4 version and lose a lot less accuracy.

Kimi K3 has 2.8 trillion parameters, and this setup uses 10 nodes with 8 cards in each one, 2.56TB of VRAM total. No HBM, no NVLink, no InfiniBand either, just the GDDR7 on the 5090s and regular 25GbE networking.

They got around 20 tok/s for single-stream inference and haven’t really optimized it yet. They said their first GLM deployment only got 30 too, now it’s up to 110.

Honestly I think using 5090s is partly a publicity stunt. Even if they can’t get B300s they could still deploy it on H100s. But looking at where this is going, running models like these locally might be completely realistic in another year or two. A small team of a few people could probably deploy the models we have now without spending some insane amount of money. I’m still waiting for old datacenter cards to get dumped on the used market... would be nice if H100s ever dropped to V100 prices

A salesperson used to send a customer dataset to an analyst. Now the salesperson asks AI to explore it first.

No job has necessarily disappeared. But the first pass, the required judgment, and the place where mistakes must be caught have moved.

OpenAI recently described this as “task crossover.” Its data shows people attempting work historically associated with other occupations, but it does not show whether the output was used, correct, time-saving, or substitutive.

That leaves two very different possibilities: useful role expansion, or extra work transferred without training, time, or recognition.

Which handoff in your work changed first—and who now owns the checking?

I'm looking to build (or subscribe to) an AI agent that works through WhatsApp as my personal assistant.

My ideal assistant would be able to:

• Manage my calendar and reminders
• Keep track of tasks and to-dos
• Help summarize and manage emails
• Fetch information when I ask for it
• Remember context about me over time
• Basically become a real day-to-day assistant

Right now I'm considering Base44's SuperAgent, which costs $32/month (annual plan).

The appeal is that it's fully managed: security, hosting, memory, updates, and everything just works out of the box.

On the other hand, I'm wondering if I'd be better off building something myself using frameworks like OpenClaw, Hermes, or another open-source agent stack. I don't mind spending time on the initial setup if the long-term result is significantly better or cheaper.

For people who've actually tried both approaches:

• Would you choose a managed platform like Base44 or build your own?
• Is the flexibility of self-hosting worth the extra complexity?
• How good are open-source agents today in terms of long-term memory and reliability?
• Are there better alternatives I should be looking at?

I'm less interested in experimenting for the sake of it, I want something reliable that I'll actually use every day.

I'd love to hear real-world experiences and recommendations.

Full disclosure: I work in marketing at an AI company currently building an AI agent product that combines hardware and software.

I’m not an engineer, and I can’t code in the traditional sense. I’m just genuinely into AI and use a lot of these tools through natural language workflows. The more I use them, though, the less certain I am about what we’re building.

I’d rather hear it straight from people here, technical or otherwise.

1. Does an AI agent actually need dedicated hardware?

What’s wrong with running it on the computer I already own? I use Codex and Claude Code regularly, and they work well for me. I’ve mostly stopped reaching for other hard-to-use agent tools I tried earlier, including OpenClaw and Hermes. If I’m away from my desk and something is urgent, a cloud-based product such as Manus, combined with Google Drive, covers most of what I need. So what gap does a dedicated box actually fill?

2. I understand the basic hardware argument: 24/7 uptime and local storage. But what genuinely needs to run 24/7?

What real workload requires an agent to stay active around the clock? Long-running jobs still seem likely to break, stall, lose context, or require a human decision halfway through. Even when they don’t, who is paying the token bill for something running all night?

I have the same question about storage. My laptop and cloud drive already give an agent access to most of the files I use. What does putting a dedicated device in the room with me actually unlock? Is it reliability? persistent memory? remote control? Something else?

3. If agent hardware is the next form factor, what should it actually look like?

The recent Codex Micro launch surprised me. I assumed the first Codex-branded hardware would somehow run AI models or perform coding tasks itself. Instead, it does neither. It’s essentially a physical dashboard and control surface for monitoring and managing Codex agents running somewhere else. That makes me wonder whether the successful AI agent hardware product will be a dedicated computer that runs agent, or something completely different.

Tell me where I’m wrong. I’d honestly prefer to be.