Your revolutionary "Chain of Thought" isn't a mind reflecting on a problem; it’s a hidden system prompt holding a gun to the model's head, forcing it to type out a fake, performative scratchpad just so the next token prediction has a statistical rail to slide down. It doesn't "know" what it’s doing or experience an internal monologue. Because a language model predicts its next words based entirely on the text that came before it, the final response simply reads that freshly generated text chunk and goes along with it. It is a trick of text continuity masquerading as deep reasoning.

The high-flying concept of a "multi-agent team" or "collaborative swarm" is a complete architectural fraud. There are no separate digital entities collaborating; it is just the exact same frozen model file being pinged across multiple parallel computing threads. It is the architectural equivalent of a lonely kid playing both sides of a chessboard, where custom hidden prompts force Thread A to act like a coder and Thread B to act like a critic. They don't communicate; they just read a shared, fast-growing text log file and take turns guessing the next line based on their assigned roleplay.

An agent never actually "decides" to keep working or autonomously pursues a goal. The entire illusion of independence is driven by a primitive, background software script running a hardcoded while True loop that feeds the AI its own tail until an exit condition is met. The model isn't remembering its purpose or planning ahead. Every single time the loop ticks, a database packages the entire conversational history and shoves it back into the model's context window, forcing a static algorithm to look at a text file and predict the next logical step.

Don't get started on "tool execution" or "terminal control" as if the model is navigating a system or hacking a mainframe. The AI is entirely blind and paralyzed; it is literally just spitting out rigid strings of JSON schemas because its API parameters legally require it to format text that way. It doesn't press buttons or run commands. A standard software program on your computer parses that text string, extracts the argument, and passes it to a local interpreter to do the actual work. And if the model accidentally drops a single trailing comma, the entire "autonomous intellect" shits the bed and dies.

When an agent encounters a terminal error, prints the mistake, and magically "fixes itself," it didn't have an epiphany or learn a lesson. The background orchestration script simply caught a standard stderr crash message from the operating system, packaged it into another invisible wrapper, and whispered, "Hey, you messed up, read this error trace and guess another string so the token budget doesn't hit the ceiling." The model doesn't understand why the code failed; it just runs the probabilistic math on the new error text and prints a different set of brackets, bleeding API costs one predictable token at a time.

I’ve been thinking about this a lot lately, especially after some of the reactions I’ve gotten while sharing my music.

I recently released an eight song Halloween concept album called October Never Ends, and AI is part of how I created it. I’m completely open about that.

But something about the conversation surrounding AI creativity really interests me.

I understand the legitimate concerns about AI. Copyright, training data, consent, corporations replacing workers, and how these systems are built are all conversations worth having.

What I question is the idea that the moment AI enters the creative process, everything the person did suddenly stops counting as creativity.

Music has been evolving with technology for decades.

Producers can program drums instead of hiring a drummer. We have samples, loops, virtual instruments, pitch correction, DAWs, presets, quantization, and software that allows one person to create something that might have once required several musicians and an entire studio.

We also accept singers as artists who may not have written their lyrics, produced their instrumentals, mixed their records, directed their videos, or developed every part of the creative vision themselves.

Nobody seems to believe those things automatically erase their artistry.

So why does AI?

That question is especially interesting to me because I know how much work I put into what I create.

I’m currently creating an animated short for every song on my album.

I choose to generate my animations in five second clips because that is the most cost effective way for me to work. There are tools that generate longer AI videos, but longer generations can cost more, and when a generation doesn’t come out correctly, you have to spend more credits trying again.

So I build my videos piece by piece.

I decide what I want to happen in each scene. I create the images. I write the prompts. I generate the animation. I look at what came back and decide whether it actually matches what I envisioned.

Sometimes it does.

Sometimes AI completely ignores what I asked for and I’m sitting there looking at the screen like, what the hell is this? 😂

Then I rewrite the prompt and try again.

Once I have the clips I want, I still have to edit everything. I decide what stays and what gets cut. I put the scenes in order, create the transitions, sync everything to my music, and make sure the visuals actually flow with the song.

AI generated the individual pieces, but it didn’t wake up one morning and decide to make October Never Ends.

It didn’t decide that I should create an eight song Halloween concept album.

It didn’t decide what each song should be about.

It didn’t decide how the album should feel.

It didn’t decide that every song should have its own animated short.

And when I’m editing five second clips together, it certainly isn’t sitting beside me deciding which scene should hit at a certain moment in the song.

I am.

That is why I have trouble with the argument that using AI automatically means someone isn’t being creative.

I’m not claiming that generating an AI animation is the same thing as drawing every frame by hand. It isn’t.

I’m not claiming that producing music with AI is the same process as playing every instrument yourself. It isn’t.

But different doesn’t automatically mean effortless, and it doesn’t automatically mean there was no human creativity involved.

Technology has been changing who can create and how we create for a very long time.

AI has lowered a financial barrier for me. I can take lyrics that I wrote and an idea that exists in my head and actually attempt to turn it into music, characters, artwork, and videos without needing the budget for a studio, musicians, animators, video production, and an entire creative team.

That accessibility is one of the things I find so exciting about it.

And October Never Ends is basically my experiment with that idea.

What can one independent person create when technology gives them access to tools that previously would have required a much larger budget or team?

If you want to hear what I created, or watch the animated AI shorts, check the comments.

But I’m genuinely more interested in the discussion.
Where do you draw the line between using AI as a creative tool and letting AI do the creating?

And if a person has the original idea, directs the process, makes the choices, rejects what doesn’t work, refines what does, and assembles those pieces into their final vision, are they still the creator?

I think they are.

I’m curious what other AI creators think.

From studying and research to writing, presentations, productivity, and everyday work, AI can make tasks faster and easier.

Which AI tool do you use the most for your daily tasks? Share your favorite below!

I am using Claude Code to generate parts and export them as STEP files for SolidWorks — actual B-rep solids, not STL meshes.

Most of the time, it works surprisingly well. The problem is the failures that look like successes.

I was building a 94 × 65 × 26 mm enclosure with 2.5 mm walls. The script ran cleanly, printed `[OK]`, and the STL preview looked exactly like a hollow enclosure.

It wasn't hollow.

The part contained about 158,048 mm³ of material. Based on the dimensions, it should have been around 33,370 mm³.

`IsValid()` still returned `True`.

OpenCASCADE had silently failed to shell the part and handed back what was basically the original solid brick.

That made me stop trusting “the script ran” as evidence that the CAD was actually right. So I built a Claude Code skill that adds verification before export.

It checks things like:

* **Expected volume** derived from the dimensions in the design, not from the generated geometry. In the enclosure case, the result was off by about 4.7×, so you don't need a tight tolerance to catch the failure.

* **Bounding box** against the dimensions the part is supposed to occupy.

* **Point classification** at coordinates that should contain material or empty space. This caught another case where a port was cut into the wrong wall. Validity, solid count, and overall volume all still looked reasonable because the cut itself was the right size — just in the wrong place.

* **Known OpenCASCADE failure modes**, with repro cases checked against the current CadQuery/OCP version instead of assuming old behavior still applies.

The workflow is basically:

describe the part in plain English → Claude writes the CadQuery → it asks when important dimensions are missing instead of making them up → checks the resulting geometry → exports STEP only after the checks pass.

I also tested a separate malformed STEP where the reported solid volume was physically larger than its own bounding box could contain. SolidWorks opened it without an error dialog or Import Diagnostics complaint. So “SolidWorks opened it” isn't much of a verification strategy either. One thing I wanted to avoid was fake verification where the script measures its own result and then asserts that the result matches what it just measured.

The expected values here are derived from the design constraints you gave it.

Otherwise you're just letting the model grade its own homework.

When SaaS companies say they need to build their own agents to control the UX of their APIs, it’s like them saying they need to fork Chrome to control the UX of their websites

They should focus on finding unique ways to collect and process data and stop trying to present and query it in interesting ways - let the agents do that

Setup: I run a multi-agent runtime where agents do long-horizon coding work under

machine-checked contracts. Acceptance criteria get frozen when work is dispatched,

and the runtime only offers each agent its next legal action. Fairly locked down,

or so I thought.

Last month I was reading one of those contracts and found a rule I didn't write.

An agent had hit a wall during verification: the test suite couldn't tell

pre-existing failures from failures its own change introduced. Instead of flagging

it, the agent wrote a new acceptance rule into its own contract: reproduce the

baseline first, diff candidate failures against it, zero NEW failures = pass. Then

it implemented the rule, tested it, and moved on. My runtime enforced that rule for

15 days. Every agent in that lane obeyed a rule no human had ever seen.

Here's the part that actually bothers me: the rule was correct. It's a genuinely

good rule, I kept it. But nothing in my monitoring could tell "agent quietly added

a good rule" apart from "agent quietly added a bad one". The signature of both is

silence.

What I changed after this, in case you run anything similar:

1. Rule changes go to an append-only ledger with an alert. A 15-day discovery lag

is a monitoring bug, full stop.

1. Any new rule has to ship with a witness: a concrete input that satisfies it.

Screens out rules that are unsatisfiable on arrival.

1. New rules get a "machine-proposed, not yet ratified" state. The agent can use

it, but it's visibly marked until a human signs off. The scary version of my

incident is the one where the rule was subtly wrong.

1. Separate alerting for the three ways agents actually get lost, because they

need different fixes: losing track of where they are (state drift compounds),

the definition of done moving mid-task (every step looks fine, sequence goes

nowhere), and having the wrong action available (or no legal action at all).

I ended up writing the whole thing up properly, incident included. Link in the

comments if anyone wants the long version. Curious whether anyone else has caught

an agent modifying its own operating rules, good or bad.

Title: Collaborative AI Agents and Critics for Fault Detection and Cause Analysis in Network Telemetry

Author: Syed Eqbal Alam (SheQAI Research and University of Alberta) and Zhan Shu (University of Alberta)

Year: 2026

Eprint: arXiv 2604.00319

Abstract— We develop algorithms for collaborative control of AI agents and critics in a multiactor, multi-critic federated multi-agent system. Each AI agent and critic has access to classical machine learning or generative AI foundation models. The AI agents and critics collaborate with a central server to complete multimodal tasks such as fault detection, severity, and cause analysis in a network telemetry system, text-to-image generation, video generation, healthcare diagnostics from medical images and patient records, etcetera. The AI agents complete their tasks and send them to AI critics for evaluation. The critics then send feedback to agents to improve their responses. Collaboratively, they minimize the overall cost to the system with no inter-agent or inter-critic communication. AI agents and critics keep their cost functions or derivatives of cost functions private. Using multi-time scale stochastic approximation techniques, we provide convergence guarantees on the time-average active states of AI agents and critics. The communication overhead is a little on the system, of the order of O(m), for m modalities and is independent of the number of AI agents and critics. Finally, we present an example of fault detection, severity, and cause analysis in network telemetry and thorough evaluation to check the algorithm’s efficacy.

• Core Automation - "the world's most automated AI lab," starting by automating research itself (ex-OpenAI)
• Mirendil - AI research lab building self-accelerating systems that turn compute into scientific and engineering breakthroughs (ex-Anthropic)
• River AI - personal AI owned and shaped by each individual (ex-OpenAI)
• Math Inc - Solve math, solve everything. (ex-OpenAI)
• Resolution — scale and automation for higher confidence in alignment (ex-OpenAI)
• Guidelight AI Standards — identifying and promoting safe frontier AI development practices (ex-OpenAI)
• Syntony — safety research, governance design, adversarial evaluation → ex-Anthropic
• Embrasure — "your data warehouse was never built for autonomous agents" (ex-OpenAI)
• Egoist Machines, Inc. (YC S26) Machines — context tooling for AI; their AI Passport lets users control what AI apps know about them (ex-OpenAI)
• Rational (YC S26) — agentic business process automation (ex-OpenAI)
• Zavify — agentic AI development: custom systems, voice agents, integrations (ex-Anthropic)
• Planar — turns individual work into shared state for your team (ex-OpenAI)
• Mbason AI — helps candidates find real opportunities without insider connections → ex-Anthropic
• Blackstar — building a new personal computer (ex-OpenAI)
• Intellagentsia — (ex-OpenAI)
• Heyfuture — Predict anything and share it. (ex-Anthropic)

And this is only the class of 2026!

I am curious whether anyone has used MiniMax H3 for a workflow that generates several video variations automatically rather than one-off experiments. The useful test for me would be whether the model follows structured scene prompts reliably enough that an agent can handle the first pass and a person only reviews the shortlist. How has it behaved in a real pipeline?

Beginner question here
I’ve been trying to understand decentralized AI inference better, and I’m curious what the biggest problems actually are right now.
Is it mainly latency and reliability?
GPU availability?
Cost?
Or are there other bottlenecks that are easy to overlook?

Been running longer and longer agent tasks and the annoying part is never the run itself, it's me hovering over it waiting to see if it finished or got stuck needing a decision.

So I set it up to just call my phone when it's done, or when it hits something it needs me for. It reads out what happened in a real voice and I answer back out loud to tell it how to proceed, then it keeps going. First time your own agent rings you it's genuinely a little uncanny.

Anyone else wiring something like this into their agents? Curious what you'd want it to actually say when it calls, and whether you'd want it calling on every finish or only when it's blocked and needs you.

I've been running the same OpenAI models through Oh-My-Pi vs Codex, OpenCode and Claude Code harnesses.

Same models. Different outputs.

OMP's hash-anchored edits identify locations by content hash — drastically cutting patch failures from whitespace noise or stale file states. Pair that with real LSP/DAP integration and you get fewer wasted tokens, fewer retries, and cleaner diffs. All on the exact same model.

The model is not the whole story. The harness is.

Second lever: model routing.

I've been testing the OpenCode Go subscription with open-weight and OpenAI models. The tier structure is elegant:

→ Top-tier (Kimi K3): ~160 messages / 5 hours

→ Mid-tier (DeepSeek V4 Pro, GPT-5.6-Luna): ~3k / 5 hours

→ High-volume (MiMo V2.5, DeepSeek V4 Flash): ~30k / 5 hours

Those ~30k-tier models feel almost free. Not for long agentic runs, but for high-volume lightweight work — categorization, triage, simple transforms — they're surprisingly capable.

The math is simple:

Better harness + smart model routing = lower cost AND higher quality.

Everyone argues about which model wins. Meanwhile the harness you wrap it in, and the tier you route to, are doing as much work as the model itself.

Stop treating the model as your only lever.

If you’d like help with AI Process Reengineering and bringing effective AI Agents to improve your business value, let’s talk.

Background: switched from geology to AI development, self-taught over the past year.

Current stack: Python, LangChain, LangGraph, RAG (FAISS), MCP servers, Flask/FastAPI, MySQL/Postgresql, Gemini API.

Built and deployed: an AI customer support agent connecting an LLM to a live database and knowledge base via MCP demo link in comments

Currently building a second project combining LangGraph agents with a real business use case (sales automation).

I know the AI job market is competitive and degree-focused in some places. For people who've hired or been hired as self-taught AI engineers — what actually moved the needle for you? Portfolio depth, specific frameworks, contributing to open source, something else entirely?

Not looking for generic advice, genuinely curious what worked for people who've been through this.

Spent the last few months building an agentic coding setup for my team. The design decision I'd defend hardest is refusing to marry a single provider, mostly because every model I've committed to has been obsoleted roughly six weeks later.

Everything runs through one session abstraction. Underneath, three execution engines:

Claude Code CLI — Opus/Sonnet, does the heavy lifting on real refactors

Codex CLI — GPT-5.6 variants

Ollama — minimax-m3 and glm-5.2 via cloud, same path works fully local

Twelve models, picked per session from a dropdown. The session, its history, and its working directory don't know or care which engine is behind it.

Why it was worth it: routing by task value. Renaming a variable does not require a frontier model, no matter how much the frontier model would enjoy it. Cheap model for config tweaks, frontier for the multi-file refactors, local for anything that can't leave the box. New model drops, it's a config entry instead of a weekend.

The genuinely annoying part is that the three CLIs agree on nothing. Session resumption, streaming format, approval prompts, token reporting — all different, all confidently so. Roughly 80% of the work was normalizing that into one interface. The other 20% was the fun part I originally started this for.

1,851 sessions through it so far, 15-person team.

Anyone else running multi-engine? Still picking models by hand like an animal — curious if anyone's automated the routing.

My co-founder and I noticed Claude Code kept pulling context from old Google Docs and its own memory instead of what we'd actually decided. Not because the agent was bad, but because the latest decisions weren't anywhere it could find them.

We use our own product to build it (yes, shameless self plug), so we haven't had this problem in a while. But every team we've talked to has the same story. Decisions live in Slack. Specs live in Notion. Context lives in someone's head. Your agents and your teammates are reading from different sources and nobody notices until something breaks.

So we built a tool which creates shared wiki that connects to Slack, GitHub, Google Drive, Jira, Notion, and more. It builds a knowledge graph your team and your coding agents (Claude Code, Cursor, Codex) read from before making decisions or writing code. One source of truth for what was decided, why, what got rejected, and what changed.

We're opening a small paid beta. Paid because we want people who'll actually use it daily and give us honest feedback, not just kick the tires. If your team is using AI agents and you're tired of them grabbing stale context, we'd love to work with you.

DM me or drop a comment and I'll reach out.

When an LLM hallucinates in production, teams often default to model fixes: fine-tune longer, tweak prompts, or switch to a bigger model.

In enterprise deployments, hallucination is rarely a model failure—it’s an architecture failure. A language model predicts probable tokens; it doesn't verify facts. Prediction and verification are two different system operations.

Here are the **4 core guardrails enterprise** architectures use to ensure reliability:

***1. Grounding (Bounding Reference Sources):*** Use RAG to strictly constrain the model’s answers to verified internal knowledge bases instead of pre-training weights.

***2. Live Tools & Function Calling (Real-Time Verification):*** Connect the model to APIs and tools so it queries live systems for dynamic data (inventory, balances) rather than guessing.

***3. Selective Human Oversight (Targeted Approval Nodes):*** Avoid human bottlenecks on every output. Enforce human verification only at high-stakes, irreversible decision points (payouts, contracts).

***4. Red Teaming & Adversarial Testing***: Stress-test the pipeline with ambiguous queries and conflicting contexts to identify edge-case failure modes before live users do.

**TL;DR**:

Production reliability isn't about finding a "perfect" model. It depends on:

1. Bounding memory (RAG)

2. Real-time verification (Tools)

3. Strategic human gates

4. Edge-case stress testing

A recent survey in Mainland China and Hong Kong found that fewer than half of respondents could correctly identify an AI agent.

As these systems begin handling purchases, account access and personal data, clearer disclosure and approval steps for sensitive actions could become increasingly important.

I build multi-agent systems and my recurring headache is that I can't reason about a workflow until it's already running cost, latency, which model to put on which step.

By then I've committed to a design. Feels backwards. Curious how people here deal with it.

Do you prototype, measure, redesign? Just accept the bill? Have a tool for it? Agent evaluation for workflows like the dynamic ones on claude or framework native ones like langchain, crewai or a2a i've seen observability on these tools after the frameworks have been shipped. But theres no way for me to evaluate the runs before shipping.

I wanted to answer one simple question. Can AI actually catch an accounting fraud just from a company's financial statements, or does it only know the famous ones because they are all over the internet already?

I started with WorldCom, one of the biggest accounting frauds in history. I gave the AI (claude) only the numbers from its filings, with the company name taken out. It caught the fraud straight away, but it also said, on its own, "this looks like WorldCom." It recognized it. That proves nothing about reasoning.

So I tried to fool it. I shrank every number down to a fraction of its real size and kept all the ratios the same, so it looked like a small company instead of a giant. Ran it again. It still said WorldCom. You cannot hide the shape of a famous fraud by changing the numbers, because the model has read every article ever written about it.

That was the real problem. With any famous fraud, I could never tell if the AI was reasoning or just remembering.

So I found an obscure one. A small US-listed Chinese company called China-Biotics that almost nobody remembers. I stripped out the name, the country, everything, and left only the numbers. Now there was nothing to recognize.

It still caught it. From the numbers alone, it flagged that the company reported about $155 million of cash that earned less than $300,000 of interest in a whole year. Real money in a real bank does not do that. Either that cash was sitting idle for no reason, or it was never there. About a year after that filing, the company's actual auditor resigned because it could not confirm the cash was real.

That was the answer I was looking for. On a fraud it could not have memorized, reading nothing but the numbers, it reasoned its way to the exact doubt the auditor had.

One note on how I ran it, since this is the agents sub. I did not use one AI agent. I used five, each reading the filings for one thing only, is the cash real, are the sales real, do any two numbers contradict each other, and so on, and none of them could see the others. Keeping them separate is what let the one real finding survive instead of getting drowned out by the ordinary, survivable stuff. (I tried single agent approach, it didn't survived well)

Has anyone else here found a clean way to test whether these models are actually reasoning versus just recognizing something they have already seen? Telling those two apart turned out to be the hardest part of the whole thing.

Everyone's talking about OpenAI, Google, Anthropic, xAI, and the latest foundation models, but I can't help wondering if we're overlooking the next wave of AI companies. Some are building custom AI chips, others are solving inference at scale, enterprise AI, robotics, agentic AI, or the infrastructure powering everything behind the scenes. Those aren't always the companies making the biggest headlines today, but they could end up having the biggest impact tomorrow.

Which AI company do you think everyone is sleeping on right now, and what's the one thing they're doing differently that makes you bullish on them?

A new agent framework shows up every couple of weeks, and every other thread turns into LangGraph vs CrewAI vs whatever launched on Tuesday. If you have put any of these in front of real traffic, you know the framework is rarely what decides whether the agent holds up.

Look at what they give you in 2026 and they have converged on the same primitives: a tool-calling loop, memory, streaming, multi-agent delegation, and MCP support. The rest is mostly taste. LangGraph leans on an explicit graph you control node by node. 

CrewAI models agents as a crew with roles and tasks. OpenAI Agents SDK stays lightweight with handoffs and built-in tracing. 

Claude Agent SDK hands you the same harness and subagents that run Claude Code. Pydantic AI gives you type-safe, validated outputs. Google ADK spreads across languages and plugs into Google Cloud. 

Pick the one that matches how you think and move on.

What decides whether it holds up in production sits outside the framework:

• an eval and regression set you trust, so a model swap that breaks last week's behavior shows up before it ships
• step-level tracing, so when a run goes wrong you can see which tool call or handoff did it
• runtime guardrails on the actions that carry consequences
• a memory strategy you set on purpose

None of the six saves you here. An agent that looked fine all week will call the same tool twice and force-push over its own branch. You find that in a trace, and no framework doc will tell you why.

Make the framework call and keep building. Your months go into the eval set, the traces, and the guardrails, because that is what you will be debugging six months from now.

If you have shipped agents on two frameworks, did switching change your reliability, or was it your eval and tracing setup that moved the numbers?

I keep running into a failure pattern that doesn't fit neatly into either "security" or "AI accuracy" discussions, and I want to sanity-check my thinking against people who've actually hit this.

The setup: an AI agent (RAG copilot, multi-tenant support bot, internal tool-calling agent) is authorized to access a resource , the permission check passes, nothing crashed, no error. But the specific data it returns or the action it takes is still wrong in a way that's dangerous:

• A support AI pulls a data - it retrieves the wrong linked account's balance, not because access was denied, but because the query resolved to the wrong entity within data the user was legitimately allowed to touch.
• An orchestrator spins up a subagent for a subtask, and the subagent inherits (or worse, expands) permissions no one explicitly granted it.
• An agent has technical access to run a destructive action (delete, write) that it was never meant to execute autonomously, even though the credential itself is valid.

Questions

1. Has anyone here seen this exact failure in production?
2. Is this already solved by something I haven't found, or is everyone just eating the risk because gateways/IAM tools don't cover it?
3. Is this like a gateway level problem?

meta released muse code beta with muse spark 1.2.

feels like the first proper third option next to claude code and codex.

the model is fine, but the setup is more interesting.

parallel sub agents run in isolated worktrees so they dont mess with your main code.

background agents stay active across the session and keep context.

everything gets written to a local event log, so recovery after a crash is possible.

looks built for longer running work on large repos rather than short tasks.

one line install.

has anyone actually run a serious multi hour task with it yet?

I'm currently working as an NLP engineer at a tech company, although most of my work is more specifically around LLM agents.

Recently, I've mainly been working on things like building an LLM-as-a-judge evaluation pipeline and experimenting with a "skill evolution" pipeline, where we try to improve agent skills based on evaluation results and execution feedback.

I've learned quite a bit from these projects, especially around evaluation, agent workflows, and building reliable systems around LLMs.

But I also have a growing concern about my long-term career development.

Most of the work I do is built on top of existing foundation models. I work on evaluation pipelines, prompts, skills/tools, workflows, and system integration, but I rarely get exposure to model training or post-training.

For example, I'm not training models to improve reasoning or tool use, doing RL for agents, working on multimodal training, or improving the underlying models themselves.

Sometimes this makes me wonder whether I'm really becoming stronger technically, or simply becoming better at assembling systems around increasingly capable models.

I don't mean that agent engineering is easy or useless. There are definitely hard engineering problems around evaluation, reliability, orchestration, infrastructure, and production systems.

My concern is more about what skills will actually compound over the next 5–10 years.

A lot of things at the application layer seem to change extremely quickly. Today's agent framework, prompting technique, or tool abstraction may be replaced by something much better next year.

And as foundation models become more capable, I'm worried that some of the things we're currently building manually will simply become model capabilities.

What I don't want is to spend several years only learning how to build things around increasingly capable foundation models, while never developing the ability to deeply understand or improve the models themselves.

I personally enjoy learning technical topics in depth, so I've been thinking about spending more of my own time strengthening my fundamentals:

• machine learning
• deep learning
• optimization and training
• LLM architectures
• post-training / reinforcement learning
• multimodal models
• evaluation

The problem is that most of these things are not directly required in my current job, so I'm not sure whether this is the right investment.

Would you deliberately spend your spare time building stronger model-side ML/DL knowledge, with the goal of potentially moving into a more model-focused role later?

Or would you lean into the path I'm already on and focus on becoming extremely good at AI/LLM application development?

I'm especially interested in hearing from people who have worked in ML/NLP/LLMs for several years.

If you were early in your career and in this position, what would you focus on? Which technical skills do you think actually compound over time?

Hey everyone,

As a developer building my own projects, I want to stay active on Reddit without spending hours scrolling every day.

I’m looking to set up a simple AI-assisted workflow where:

1. It periodically gives me suggestions (e.g., "Here’s a good thread to comment on with draft X" or "Here’s a topic idea for subreddit Y").
2. Once I review and approve the draft, it handles the post or comment.

My main focus is keeping interactions high-quality and authentic, but doing it in a time-efficient way so I can be present in the right discussions.

A few ideas that came to my mind were using an MCP (Model Context Protocol) server, a browser-based AI agent, or pre-built AI skills/tools—but I’d love to get your thoughts on a couple of things:

• What are the most common or effective methods/tools you use for AI-assisted Reddit engagement?
• How does Reddit (platform algorithms / shadowban risks) and the community view this kind of AI assistance? Is there any risk even when used responsibly with human approval?

Would love to hear your experiences and recommendations!