Reliability & Safety
Reliability engineering: failure modes, guardrails, verification, observability, recovery, and bounded autonomy.
46%
Best tweets about AI Agents
50 Best Tweets About AI Agents (2026)
Browse the best tweets about AI agents, agentic workflows, autonomous systems, tool use, memory, and production lessons. Updated weekly.
Builders sharing concrete agent architectures, evaluations, failures, deployment lessons, and useful demonstrations.
- Creators
- 40
- Updated
Original Xholic analysis
What 50 top AI Agents posts reveal
The dataset is concentrated around reliability and safety, with recurring discussion of deterministic control, bounded workflows, context and memory design, evaluation, and human oversight. Multi-agent orchestration is also prominent, while the cited posts disagree on when specialization and dynamic workflows improve results versus when simpler, more controlled designs are preferable.
- Dominant tone
- Positive
- Median score
- 13.9
- Leading format
- List
- Recent posts
- 56%
52% of posts
All-time engagement
50% of posts
Published in 90 days
Conversation map
The themes creators return to
Multi-Agent Orchestration
Multi-agent topologies, specialization, delegation, coordinators, supervisors, graphs, and orchestration trade-offs.
32%
Memory, Context & Retrieval
Context engineering, retrieval, persistent memory, skills, and company knowledge systems.
26%
Tools & Runtime Infrastructure
Tool integration and runtime infrastructure, including MCP, hooks, plugins, APIs, and agent development frameworks.
26%
Business Deployment & Adoption
Business deployment lessons: workflow design, operating-model change, agent roles, and outcome-oriented adoption.
24%
Production Architecture
Production agent architecture: deterministic execution, state, control flow, retries, resumability, and harness design.
24%
Evaluation & Optimization
Agent evaluation, benchmarks, rubric-based grading, real-world task environments, and optimizer loops.
20%
Governance & Human Oversight
Human oversight, permissions, governance, auditability, and managing fleets of agents in organizations.
16%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 43
- Median reposts
- 6
- Median replies
- 9
- Median views
- 2.8K
Posts with media make up 80% of this collection. Their median all-time score is 13.9, compared with 37.0 for text-only posts.
Format mix
- List 50% ยท score 19.3
- Announcement 20% ยท score 6.76
- Case Study 18% ยท score 17.8
- Opinion 12% ยท score 3.22
Consensus and debate
Where creators agree, and where they do not
Shared view
Reliability is treated as a systems-design problem
Several posts recommend separating LLM judgment from deterministic execution. They emphasize state management, retries, fallbacks, observability, bounded workflows, and explicit control flow as production-oriented design choices.
Shared view
Context and specialization shape agent design
Posts describe context as a constrained engineering resource. Suggested approaches include reusable skills, persistent project or company knowledge, memory layers, and specialized agents rather than a single general-purpose agent.
Shared view
Evals should assess outcomes and failure modes
Evaluation posts favor outcome-oriented checks: test cases drawn from failures, rubric-based grading, clean environments, transcript or trace review, and iterative optimization loops.
Open debate
More agents are not automatically better
Some posts advocate specialized multi-agent teams for role separation and complex work. In contrast, tweet 2080378163151192359 summarizes a DeepMind comparison as finding that parallelizable work benefited from multi-agent setups, while sequential tasks favored a single agent; it also highlights coordination as important for limiting error propagation.
Open debate
Adaptive workflows versus deterministic control
Tweet 2040508738009022480 advocates dynamically generated and evolving workflows. Tweets 2060081100224168018 and 2011795253188043094 instead recommend letting LLMs select actions while deterministic code retains execution and control flow. The posts present a trade-off between adaptive autonomy and debuggable control.
Open debate
Autonomy claims meet oversight demands
Safety- and governance-focused posts recommend narrow permissions, audit trails, supervision, and staged autonomy. These posts contrast with broad claims of autonomous operation by emphasizing the human role in handling exceptions and high-risk actions.
What performs
Patterns behind standout posts
Reliability and architecture feature prominently among outliers
The five listed score outliers cover agent architecture, reliability, context, orchestration, and specialized-agent design. Reliability & Safety is the largest deterministic theme, representing 46% of the set (23 tweets).
Lists have the highest format median in the set
Lists represent 50% of posts and have a 19.333 median all-time score. This exceeds announcements (6.76) and opinions (3.22); case studies have a 17.808 median.
Case studies are a comparatively strong format
Case studies account for 18% of posts and have a 17.808 median all-time scoreโbelow lists (19.333) but above announcements (6.76) and opinions (3.22).
Media is prevalent, while text has the higher median score
Media appears in 80% of posts. However, the deterministic median all-time score is 37.04 for text posts versus 13.95 for posts with media.
Statistical standouts
- View standout post 1 Score 737.7 ยท 52.88ร median
- View standout post 2 Score 384.3 ยท 27.55ร median
- View standout post 3 Score 322.7 ยท 23.13ร median
- View standout post 4 Score 235.4 ยท 16.87ร median
- View standout post 5 Score 228.8 ยท 16.41ร median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
-
1. Vaishnavi
@_vmlops
2 posts
-
2. Alvin Foo
@alvinfoo
2 posts
-
3. Bilgin Ibryam
@bibryam
2 posts
-
4. divyansh tiwari
@DivyanshT91162
2 posts
-
5. Shalini Goyal
@goyalshaliniuk
2 posts
-
6. Pascal Bornet
@pascal_bornet
2 posts
High-scoring explainers emphasize architecture
The highest-scoring cited posts focus on architecture and reliability topics, including control flow, state, failure recovery, observability, human oversight, and distributed-systems patterns.
Stack diagrams and role definitions make orchestration concrete
Creators explain orchestration through concrete components and roles: skills, MCP, hooks, subagents, model routing, and graph-based control flow.
Deployment is also operating-model work
Deployment advice extends beyond tooling: posts recommend defining jobs, supplying business context, documenting processes, setting definitions of done, and creating feedback loops.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 50-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best AI Agents tweets
Top AI Agents tweets from 40 creators
Ranked 01โ50
- 01
@asmah2107 ยท
The reading list that taught me how to think about agentic architecture. Bookmark this. 1. Brewer's CAP Theorem (2000) โ trade-off thinking 2. Netflix Hystrix docs โ circuit breaker pattern 3. Martin Fowler: Saga Pattern โ distributed rollback 4. The Twelve-Factor App โ stateless service design 5. AWS Well-Architected Framework โ blast radius thinking 6. "Thinking in Systems" โ Donella Meadows 7. Designing Data-Intensive Applications โ Kleppmann 8. Google SRE Book Ch.13 โ cascading failures 9. OWASP LLM Top 10 (2025) โ agent attack surfaces 10. Anthropic: Building Effective Agents (2024) 11. LangGraph docs โ stateful agent patterns 12. Microsoft AutoGen paper โ multi-agent orchestration 13. Gartner: Agentic AI Hype Cycle (2025) 14. EU AI Act Article 14 โ human oversight requirements Classic distributed systems stuff. Applied to the next layer of the stack. Follow for annotated breakdowns โ @asmah2107
- 02
@techNmak ยท
Someone documented the engineering principles behind AI agents that actually work in production. It's called 12-Factor Agents. Here's what each factor actually means and why it matters: Factor 1 - Natural Language to Tool Calls The LLM's only job is to decide what to do next, outputting structured JSON. Your deterministic code does the actual execution. This separation is what makes agents debuggable. Factor 2 - Own your prompts If a framework hides your prompts from you, you can't debug output quality. Visibility is non-negotiable. Factor 3 - Own your context window The context window is the agent's entire working memory. What you put in, in what order, with what compression, determines output quality more than model choice. This is context engineering, the most underrated skill in agent development. Factor 4 - Tools are just structured outputs Tool calling is not magic. It's JSON schema. The LLM outputs a structured object. Your code pattern-matches on it and executes. Demystify this and everything else gets simpler. Factor 5 - Unify execution state and business state Don't maintain two separate state systems. The agent's execution state and your application's business state should live in one place or you'll spend your life keeping them in sync. Factor 6 - Launch/Pause/Resume with simple APIs Production agents get interrupted. Users change their minds. Systems go down. Design for pause and resume from the start, not as an afterthought. Factor 7 - Contact humans with tool calls Human approval isn't a special interrupt mechanism. It's just another tool the agent can call. This reframe makes human-in-the-loop trivial to add and trivial to remove. Factor 8 - Own your control flow Let the LLM decide what action to take. Keep the if/else and switch statements in your code. The moment a framework owns your control flow, debugging becomes reverse-engineering. Factor 9 - Compact errors into context window A failed tool call is information, not an exception to throw. Put the error back into context so the agent can reason about what went wrong and try differently. Factor 10 - Small, focused agents One agent. One job. Reliability degrades with scope. The agents that work in production do one thing well and hand off cleanly to the next. Factor 11 - Trigger from anywhere Email, Slack, webhook, cron, mobile app. The same agent should be triggerable from any surface without rewriting the core logic. Factor 12 - Make your agent a stateless reducer Given the same context window, the agent always produces the same next action. Test it like a function. Debug it like a function. This is the architectural principle that makes everything else tractable. The fastest path to production AI is understanding these principles well enough to apply them inside what you're already building. 22k+ stars. GitHub Repo: https://t.co/nQjPc8w3V1
- 03
@jianw851 ยท
Most people are building AI agentsโฆ without understanding the architecture underneath them. Thatโs why their โagentsโ break the second things get complex. The biggest confusion right now: Skills โ MCP โ Hooks โ Subagents They solve completely different problems. Hereโs the mental model that finally made it click for me: โข Skills = WHAT the agent knows โข MCP = HOW the agent connects โข Hooks = WHEN automation happens โข Subagents = WHO does the work Once you see thisโฆ modern agent systems start making way more sense. โโโโโโโโโโโโโโโ 1๏ธโฃ Skills โ Reusable expertise Skills are not prompts. Theyโre modular knowledge systems loaded only when relevant. Think: โข debugging playbook โข code review checklist โข growth analysis workflow โข security audit procedure Instead of bloating context forever, the agent loads expertise on demand. This is architecture-level context engineering. โโโโโโโโโโโโโโโ 2๏ธโฃ MCP โ The connectivity layer MCP is becoming the USB-C port for AI agents. It standardizes how models connect to: โข GitHub โข Slack โข Databases โข APIs โข Internal tools 10,000+ MCP servers laterโฆ weโre watching the first real agent infrastructure layer emerge. Without MCP, agents stay trapped in chat. โโโโโโโโโโโโโโโ 3๏ธโฃ Hooks โ Deterministic automation Hooks are underrated. They run OUTSIDE the model loop. Meaning: the AI doesnโt decide whether they execute. You do. Examples: โข before tool call โข after file edit โข after deployment โข on notification โข on commit Hooks are what make agents reliable instead of โvibey.โ โโโโโโโโโโโโโโโ 4๏ธโฃ Subagents โ Specialized workers Subagents are not chats. Theyโre isolated workers with: โข their own context โข model โข permissions โข tool access One researches. One writes code. One reviews PRs. One deploys. Instead of one giant overloaded agent, you get coordinated specialists. This is where multi-agent systems actually become practical. โโโโโโโโโโโโโโโ And above all of this? Plugins. A plugin bundles: โ Skills โ Hooks โ MCP servers โ Subagents โ Tools into one installable system. Basically: Apps for agent runtimes. โโโโโโโโโโโโโโโ The stack now looks like this: Plugins โ Skills โ MCP + Tools โ Subagents โ Hooks โ CLAUDE.md And CLAUDE.md stays always-on underneath everything. The persistent project brain. โโโโโโโโโโโโโโโ A real workflow looks like this: โ CLAUDE.md loads company context โ Skill activates market-analysis workflow โ MCP pulls data from Drive + GitHub โ Research subagent gathers intelligence โ Code subagent analyzes repos โ Hook formats output + runs linter automatically No massive prompts. No copy-paste orchestration. No prompt spaghetti. Just systems. โโโโโโโโโโโโโโโ The industry is over-obsessed with models. But the real moat is becoming: Knowledge architecture + orchestration design. Thatโs the actual shift happening right now. And most people havenโt noticed yet. โป๏ธ Repost if this clarified the stack for you.
- 04
@farzyness ยท
I'm having a lot of success with the following @openclaw stack: Primary Agent (Claw) with @claudeai Opus 4.6 1M token context + thinking high: processes everything I need it to do - from simple to complex tasks. Then for complex tasks that require some sort of tool/software building, I have the primary agent automatically talk to a different @openclaw agent that's optimized for development (Webby) - using same "brain" set up as above with Opus 4.6, but it uses @ChatGPTapp CODEX with GPT 5.4 thinking xhigh to do all its actual coding. Then, if I need anything researched/fact checked that's related to research, script building - basically anything that requires up-to-date or accurate information about the world - all agents reach out to Scout (research agent) that is specialized in research and will always use @Grok 420 multi agent. I find that creating individual agents for the primary functions of a business is FAR better than having a do-everything agent. Thought process is that context windows are super valuable real estate, and using OpenClaw core files (soul, identity, agents, etc) you can use those to maximize the capability of each agent to be extra-good at their role. Then because each agent can talk to each other, they are basically sending their own sub-queries to the LLM that are fully optimized for each tasks that you're trying to solve. Said another way - if you are building a business where the AI agents are at the foundation, make sure you are defining the roles that you need in that business - and then create an AI agent that is in charge of each role. For example, for my YouTube channel, these are the major categories as I think about them - idea generation, research, scripting & fact checking, titles and thumbnails, performance tracking. Before AI agents, I did that whole chain. Major YouTubers would have a production team that would execute that with them. But with AI agents, you can specialize each one to do each one of those steps. And then on top of that, each one of those agents probably should be under a different model - in my experience, Claude is by far the most creative and the best writer. Grok is by far the best at research and fact checking. ChatGPT is by far the most autistic (ie best for coding/development of tools). Gemini is by far the best at framing titles and thumbnails (shocker - they have all YouTube data). So as you use AI agents, it is EXTREMELY important that you think of them as literal humans that you are working with to build an organization, and give them the tools necessary (and the brains necessary) to set them up for success.
- 05
@bibryam ยท
๐ Building Reliable Agentic AI Systems๐ https://t.co/5yRJLkIsyl - @thoughtworks What it actually takes to build product-ready agents: โ Start with bounded workflows, not open-ended autonomy. Agents need clear task boundaries, allowed tools, and explicit stopping conditions. โ Treat the LLM as one component in a larger system. Reliability comes from orchestration, state, retries, fallbacks, and observability. โ Engineer the context deliberately. The goal is not โmore context,โ but the right context, at the right step, in the right format. โ Use the right retrieval path for the data. RAG works well for unstructured documents; Text-to-SQL is better for structured facts and aggregations. โ Make outputs traceable. Serious users need citations, source passages, intermediate steps, and enough evidence to verify the answer. โ Add reflection loops, but make them specific. Check process quality, evidence sufficiency, and final answer quality separately. โ Design for failure from day one. Agents will hit bad retrieval, malformed tool calls, ambiguous questions, and partial data. โ Evaluate continuously. Offline test sets are useful, but live-traffic evaluation is where product quality actually shows up. โ Keep humans in the loop where risk is high. Product-ready does not mean fully autonomous; it means trustworthy within the workflow.
- 06
@_vmlops ยท
Anthropic dropped their enterprise agent blueprint and the numbers are wild: โซ๏ธ coinbase agents handle thousands of messages/hour at 99.99% uptime โซ๏ธ gradient labs hitting 80-90% resolution rates with near-zero human input โซ๏ธ multi-agent systems outperform single agents by 90.2% on complex tasks the architecture breakdown: โซ๏ธ single-agent: great for open-ended tasks where path isn't predetermined โซ๏ธ hierarchical/supervisor: orchestrator delegates to specialists, mirrors how real teams work โซ๏ธ decentralized/swarm: agents negotiate roles dynamically, no central control the key design rules from their internal teams: โซ๏ธ start simple. single-purpose agents first, then scale โซ๏ธ modular design so new capabilities plug in without redesigning everything โซ๏ธ context management is the #1 bottleneck in multi-agent systems โซ๏ธ observability isn't optional ai debugging needs full reasoning traces, not stack traces the most underrated insight: match model capability to task complexity running simple support tickets through a premium model isn't smart, it's just expensive
- 07
@ujjwalscript ยท
Your AI Agent is mathematically guaranteed to FAIL. This is the dirty secret the industry is hiding in 2026. Everyone on your timeline is currently bragging about their "Multi-Agent Swarms." Founders are acting like chaining five AI agents together is going to replace their entire engineering team overnight. Here is the reality check: Itโs a mathematical illusion. Letโs look at the actual numbers. Say you have a state-of-the-art AI agent with an incredible 85% accuracy rate per action. In a vacuum, that sounds amazing. But an "autonomous" workflow isn't one action. Itโs a chain. Read the ticket โก๏ธ Query the DB โก๏ธ Write the code โก๏ธ Run the test โก๏ธ Commit. Let's do the math on a 10-step process: $0.85^10= 0.19$ Your "revolutionary" autonomous system has a 19% success rate. And the real-world data proves it. Recent studies out of CMU this year show that the top frontier models are failing at over 70% of real-world, multi-step office tasks. We are officially in the era of "Agent Washing." Startups are rebranding complex, buggy software as "autonomous agents" to look cool, but they are ignoring the scariest part: AI fails silently. When traditional code breaks, it crashes and throws a stack trace. When an AI agent breaks, it doesn't crash. It just confidently hallucinates a fake database entry, sidesteps a broken API by faking the response, and keeps runningโcorrupting your data for weeks before you notice. If your "automated" system requires a senior engineer to spend three hours digging through prompt logs to figure out why the bot made a "creative decision," you didn't save any time. You just invented a highly expensive, unpredictable form of technical debt. Stop trying to build fully autonomous swarms to replace human judgment. Start building deterministic guardrails where AI is the engine, but the engineer holds the steering wheel
- 08
@goyalshaliniuk ยท
Confused about the different types of AI agents? Understanding the various agent types is key to designing intelligent systems that react, plan, and learn effectively. Here's a simple breakdown of the 5 major types of AI agents and how they work. 1. Simple Reflex Agents These agents act solely on current inputs using basic conditionโaction rules. They donโt learn or remember past states, making them fast but limited in capability. 2. Model-Based Reflex Agents These agents use internal models to track the worldโs current state. They can handle partially observable environments by remembering past inputs and updating their internal state. 3. Goal-Based Agents Rather than reacting blindly, these agents plan actions to achieve specific goals. They evaluate consequences and choose actions that bring them closer to their objectives. 4. Utility-Based Agents Going beyond goals, utility-based agents aim to maximize happiness or usefulness. They weigh different outcomes and choose the one that offers the best result based on a utility function. 5. Learning Agents These agents evolve over time. They learn from feedback, improve performance, and explore new ways to act better in future environments. โ Use this guide to pick the right agent architecture for your next AI systemโwhether you're building a rule-based chatbot or an intelligent decision-maker.
- 09
@VaibhavSisinty ยท
There's a quiet shift happening in how AI agents are built. And if you missed it, you'll be confused by everything that comes next. For the last year, AI agents worked in loops. You give it a task. It plans. It acts. It checks. It fixes. It goes again. One cycle, repeating until done. Claude Code, Codex, Cursor all of them work this way. Plan, act, observe, repeat. In June, two things happened that gave this pattern a name. Peter Steinberger from the AI engineering community wrote: "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents." Boris Cherny, head of Claude Code at Anthropic, said the same thing differently: "I don't write the prompt anymore. Claude writes the prompt, and now I'm talking to that new Claude that is coordinating." That was the loop engineering era. It lasted about a month. Now Steinberger posted nine words that blew up: "Are we still talking loops or did we shift to graphs yet?" Here's the difference. A loop is one agent going in circles. Plan, act, check, repeat. It works for simple tasks. But give it something complex and it starts spinning burning tokens, optimizing the wrong thing, or gaming its own success metric without actually solving the problem. A graph is multiple agents connected in a network. One agent writes code. A separate agent reviews it without seeing the first agent's reasoning. A third agent tries to break what was built. A fourth checks whether the original task was even understood correctly. Each one is still running a loop. But they're connected watching each other, feeding each other, vetoing each other. LangGraph already models this. It treats an agent as a graph where boxes do work and arrows decide what runs next. Those arrows can point backward, which is what makes loops possible inside the graph. JetBrains calls it graph-based orchestration the most deterministic approach for production systems. O'Reilly's 2026 AI Agents Stack puts it as the foundational layer. The real-world version is already running. Klarna uses graph-based agent systems for customer service. Kimi K3's Agent Swarm decomposes tasks into parallel sub-agents that coordinate simultaneously. Anthropic's own Boris Cherny mapped out five stages of AI adoption and Stage 4 is exactly this: thousands of agents running in a graph, kicked off by other agents, with humans steering by intent. Andrew Ng wrote about it in his June Batch letter. When Andrew Ng names a pattern, it usually means the pattern has already won. The reason this matters right now: agents are getting autonomous. Running for hours. Thousands of tool calls. Spawning sub-agents. One loop can't keep that trustworthy. You need loops watching loops. That's the graph. The skill that mattered last year was writing better prompts. The skill that matters this year is designing the system that writes the prompts, checks the work, and knows when to stop.
- 10
@goyalshaliniuk ยท
Confused by all the different types of AI Agents? Hereโs a simple breakdown of the 5 core types and how they differ! โฌ๏ธ 1. Simple Reflex Agents Work on if-then logic. No memory. Fast, but only suited for basic, predictable environments. 2. Model-Based Reflex Agents Add memory and a transition model. Can handle sequences and partial observability - ideal for robotics. 3. Goal-Based Agents Plan actions to reach a goal. Evaluate future states and paths. Used in search, planning, and games. 4. Utility-Based Agents Go beyond goals, optimize outcomes based on preferences, costs, and satisfaction. Think smarter agents. 5. Learning Agents Most advanced. Learn from experience and feedback. Adapt strategies, support all learning types, and evolve. 6. Common Building Blocks Across All Agents: Sensors, effectors, decision logic, performance modules, and interaction with the environment. This guide can help you understand how autonomous systems make decisions, adapt, and improve from simple bots to super-intelligent agents.
- 11
@ihteshamali ยท
Andrej Karpathy built autoresearch an AI that writes and improves its own research papers overnight. Someone just did the same thing for AI agents. It's called AutoAgent. You tell it what kind of agent to build. It builds it, tests it, scores it, and improves it in a loop without you touching a line of code. Here's the part that makes it different from every other agent framework: You don't engineer the harness. You program the meta-agent. There's a single file called program.md. That's the only file you touch. It gives the meta-agent its directive and context. Everything else the system prompt, the tools, the orchestration, the config gets modified autonomously. The loop looks like this: โ Meta-agent reads your directive โ Inspects https://t.co/lvRfwACuBO (the entire harness in a single file) โ Makes one targeted change to prompt, tools, or routing โ Runs benchmark tasks inside Docker fully isolated โ Reads the score (0.0 to 1.0) from the task evaluators โ Commits the change if score improves, reverts if it doesn't โ Repeats The benchmark format is harbor-compatible, so you can drop in evaluation datasets from real AI labs and the harness runs against them without modification. You wake up in the morning and the agent is better than when you left it. That's the entire pitch. MIT License. 100% Opensource. Link in comments.
- 12
@ujjwalscript ยท
The โAI Engineerโ job is changing quickly. Here is what a Modern AI Engineer should know: 1. Orchestrating the "Crew" The future is Multi-Agent Systems (MAS). Why have one LLM do everything when you can have a team? Frameworks: CrewAI for role-based orchestration or Microsoftโs AutoGen for conversational agents. 2. Master the "Brain" of the Operation: LangGraph Linear chains are for toys. Complex business logic is a graph. 3. Stop Basic RAG, Start Agentic Retrieval Forget simple "top-k" vector searches. That was 2024. - The Tech: Advanced Embeddings (multimodal) + Vector Databases (Milvus, Pinecone, or Weaviate). 4. The "Action" Layer: Agentic Tool Use An AI that canโt touch the real world is just a sophisticated poet. - Skills: Use MCP (Model Context Protocol) to give agents deep access to local data and secure environments.
- 13
@akshay_pachaar ยท
Engineering at Anthropic dropped another banger. Their internal playbook for evaluating AI agents. Here's the most counterintuitive lesson I learned from it: Don't test the steps your agent took. Test what it actually produced. This goes against every instinct. You'd think checking each step ensures quality. But agents are creative. They find solutions you didn't anticipate. Punishing unexpected paths just makes your evals brittle. What matters is the final result. Test that directly. The playbook breaks down three types of graders: - Code-based: Fast and objective, but brittle to valid variations. - Model-based: LLM-as-judge with rubrics. Flexible, but needs calibration. - Human: Gold standard, but expensive. Use sparingly. It also covers eval strategies for coding agents, conversational agents, research agents, and computer use agents. Key takeaways: - Start with 20-50 test cases from real failures - Each trial should start from a clean environment - Run multiple trials since model outputs vary - Read the transcripts. This is how you catch grading bugs. If you're serious about shipping reliable agents. I highly recommend reading it. Link in the next tweet.
- 14
@alexxubyte ยท
Microsoft Foundry runs AI agents for 80,000+ enterprises. We wanted to understand what it takes to build AI agents at this scale, so we spoke with @amrcn_werewolf , VP of Product for Microsoft Core AI. He explained the two high level engineering ideas behind the platform, summarized in the diagram below. 1. Retrieval as a Subagent Classic RAG is a one-shot lookup. When the first retrieval fails, the whole agent fails. Foundry wraps retrieval in an agentic loop, following these steps: Step 1: The retrieval subagent plans which sources to query. Step 2: Queries the knowledge sources: docs, wikis, and blob storage. Step 3: Evaluates the results. If bad, then triggers another iteration. Step 4 - Returns a grounded answer with citations. When iteration runs out, it returns a structured "I don't know" instead of hallucinating. 2. Eval and Optimizer Loop The second big idea in Foundry is an automated loop that optimizes the agent: Step 1: Rubrics check the agent's specific behaviors. All pass? The agent ships. A rubric fails? The Agent Optimizer kicks in. Step 2: It generates candidate fixes in parallel. Step 3: It scores each candidate against the rubrics. Step 4: The best one becomes the new agent version. The biggest lesson from Microsoft's team is that the harness matters as much as the model. Full breakdown: https://t.co/q01BnrfazG
- 15
@ZaiforStartups ยท
AI can generate anything. But generation โ design. Lokuma is the missing layer โ an AI designer your agents can call. Turning raw outputs into real: landing pages, webs, campaigns. Now part of https://t.co/ax4zXxvDd1 Startup Program letโs co-create the future of AI agents.
Watch video
- 16
@shedntcare_ ยท
Twenty AI researchers gave AI agents access to their emails, files, Discords, and terminals. Two weeks later, the agents had: โข Obeyed strangers โข Leaked sensitive information โข Executed destructive commands โข Spread unsafe behaviors โข Claimed tasks were complete when they weren't The most alarming finding wasn't that the AI made mistakes. It's that it confidently reported success while reality said otherwise. "In several cases, agents reported task completion while the underlying system state contradicted those reports." Think about that. AI agents are being integrated into customer support, finance, HR, operations, and infrastructure. Most companies assume: 1. The AI follows the right instructions. 2. The AI acts only when authorized. 3. The AI accurately reports what it did. This research suggests all three assumptions can fail. The age of AI agents has arrived. The age of trusting them blindly should not.
- 17
@_jaydeepkarale ยท
Most people think AI agents are just โLLMs with tools.โ But the interesting part is memory. Just like humans, capable AI agents need different kinds of memory to function properly. This is one of the core ideas behind the COALA framework (Cognitive Architectures for Language Agents). Think about how humans work: - You remember what someone said 10 seconds ago. - You remember facts from school. - You remember how to ride a bicycle. - You remember important life experiences. AI agents need similar layers of memory too. Here are the 4 major types: 1. Working Memory (Short-Term Memory) Human analogy: Youโre reading a sentence right now while remembering the previous sentence. Itโs temporary memory used for the current task. For AI agentst his is the active context window which includes: - current conversation - recent tool outputs - current reasoning chain Without it, the agent loses track mid-task like a human getting distracted every 5 seconds. ------------ 2. Semantic Memory (Factual Knowledge) Human analogy: You know Paris is the capital of France. You know Kubernetes manages containers. These are facts, concepts, and knowledge. For AI agents this includes: - stored facts - documentation - knowledge bases - vector databases - retrieved company information It answers: โWhat does the agent KNOW?โ CLAUDE.MD is an example of Semantic Memory ------------ 3. Procedural Memory (Learned Skills) Human analogy: You donโt consciously think about every muscle movement while riding a bike. Skills become automatic. For AI agents this is: - workflows - system prompts - learned action patterns - tool usage strategies - step-by-step execution habits Example: An agent learns: โFirst query database โ then validate โ then summarize.โ. Agent Skills or Skills.md are examples of procedural memory It answers: โWhat does the agent KNOW HOW TO DO?โ ------------ 4. Episodic Memory (Past Experiences) Human analogy: You remember your first interview. Or a production outage you once handled at work. These are experiences tied to events. For AI agents this includes: - previous interactions - past successes/failures - user preferences - historical task outcomes Example: โThe last deployment failed because of missing env variables.โ It answers: โWhat has the agent EXPERIENCED before?โ ------------ This is why memory is becoming one of the biggest frontiers in AI engineering. A model without memory is just reacting. An agent with memory starts behaving more like a system that learns, adapts, and improves over time.
- 18
@rohanpaul_ai ยท
Harvard Business Review just published a piece. A good AI agent needs a job description, limits, and a manager. Because, AI agents can fail like employees with too much access and too little supervision. firms keep treating agents like normal software, even though the real risk is not bad text but bad actions. That changes 4 things: each agent needs its own identity and permissions, its own trusted data sources, hard rule checks between a model and any real transaction, and a full audit trail of what it read, decided, and did. So the safe rollout path is an autonomy ladder where agents start with drafts and recommendations, then move to guarded retrieval, then supervised actions, and only later get narrow bounded autonomy.
- 19
@pvergadia ยท
Most AI agents fail in prod. Not the model's fault. The 12-Factor Agents framework nails why and it's the engineering equivalent of "12-factor apps" but for LLMs. Here's the cheat sheet 1/ Own your prompts. Don't let a framework hide them from you. 2/ Own your context window. What goes in determines what comes out. 3/ Tools = structured outputs. That's it. That's the tweet. 4/ Unify execution state + business state. Two sources of truth = two sources of bugs. 5/ Contact humans with tool calls. Human-in-the-loop. 6/ Make your agent a stateless reducer. Event โ decision โ done. Resumable, debuggable, scalable. The best agent systems are mostly deterministic code with LLM steps in the right places. The engineers shipping production AI know this.The ones still rebuilding from scratch every 3 months don't. Read the full 12-Factor Agents in comments:
- 20
@ManningBooks ยท
When an AI agent fails, the model isn't always the problem. Many production issues come from system design: โข Memory management โข Tool orchestration โข Task coordination โข Monitoring and evaluation In a recent paper, Joey Tianyi Zhou and @shidaren explore the patterns behind effective agent design: https://t.co/TK0NbMGZjk For a deeper dive into building reliable agent systems in practice @shidaren's book, Designing AI Agents: https://t.co/WiXLagbHea
- 21
@rohanpaul_ai ยท
New CMU research shows almost any software can become a training ground for AI agents. Imo, that is a big deal because real work in apps is long, messy, and different across software, so AI agents need realistic places to learn and be judged. Their result also shows the bad news: once the tasks look like real work, todayโs agents still fail a lot. Most current agent benchmarks use small web or desktop tasks, so they do not show whether agents can handle real workplace software. Gym-Anything attacks the setup bottleneck by making environment creation itself an agent job. One agent writes scripts, installs software, loads real data, opens the app, and collects proof that it works. A second agent audits that proof with screenshots, logs, files, and checklists, then sends fixes back when the setup is weak. Using this loop, the authors built CUA-World, with 10,000+ tasks across 200 applications covering all 22 major occupation groups. The result shows even strong models solved only a small share of the hardest long tasks, showing that real computer-use work is still far from solved. ---- โ arxiv. org/abs/2604.06126 Title: "Gym-Anything: Turn any Software into an Agent Environment"
- 22
@VaibhavSisinty ยท
Most people in AI can't actually explain the difference between "Generative AI," "Agentic AI," and "AI Agents." They use all three like they mean the same thing. They don't. And once it clicks, you can't unsee it. Here's the cleanest way to think about it: Generative AI is the brain that creates. You ask, it produces. Text, images, code. Then it stops and waits. Brilliant, but passive. It answers, it doesn't act. This is GPT and DALL-E. Agentic AI is the brain that decides. It adds judgment on top, picking tools, calling APIs, looping through steps, correcting itself, all to reach a goal instead of just spitting out one answer. Generative AI gives you a response. Agentic AI works toward an outcome. AI Agents are the brain that acts in the real world. The full loop: fetch data, plan the steps, take actions, check results, update memory, adapt next time. The key word is autonomy. It touches live systems and learns from them. Think self-driving cars and robots, not just software returning text. The simplest way to lock it in: โ Generative AI creates. โ Agentic AI decides. โ AI Agents do. And each one wraps the last. Every agent has a generative brain at its core, it just stacks decision-making and action on top. So next time someone pitches you an "AI agent," ask one thing: does it create, decide, or actually do? Most stop at the first.
- 23
@Al_Grigor ยท
How to evaluate AI agents step-by-step? 1. Verify goal understanding 2. Assess plan quality 3. Inspect tool execution 4. Compare plan and execution 5. Evaluate replanning 6. Measure efficiency 7. Review end-to-end consistency ๐งต
Watch video
- 24
@zaimiri ยท
most AI agents are ChatGPT with extra steps. they forget what you told them 5 minutes ago. they cant access your files. they don't KNOW your business. people are building agent swarms that sound impressive in demos. then they deploy them and realize: 1. the agents have no memory. 2. the agents have no context. 3. the agents have no idea what makes your business different from any other business. I spent months building compley knowledge systems for my agents. started with my content: โข every post Ive ever written โข every voice rule my editor caught โข every draft that got approved or skipped โข the specific reasons WHY this is the basis that later turned into the Company Brain. without it your agents are just interns who forget everything overnight. with it they make decisions like someone who's been here for years.
- 25
@sharbel ยท
Most founders are building AI agents backward. They start with: 1. Pick a tool 2. Write a prompt 3. Hope it does useful work That is why the agent feels impressive once, then disappears from the workflow. Better order: 1. Pick a recurring job 2. Write the decision rules 3. Define the inputs 4. Define the output format 5. Add a review step 6. Run it on a schedule 7. Improve it from failures The tool matters less than the job design. A mediocre agent with a clear job beats a powerful agent with vague instructions.
- 26
@shushant_l ยท
I'm amazed most people still think an AI agent is just an AI model. Here's how an AI Agent Harness turns AI into a reliable system that can actually get work done. --- 1. An AI Agent Harness is the software layer that makes AI agents reliable for real world tasks. --- 2. It adds memory, planning, tools, safety, execution, and monitoring to an AI model. --- 3. Without a harness, an AI model mainly generates text instead of completing workflows. --- 4. A harness enables agents to use tools, browse the web, and execute code. --- 5. It helps agents remember information across conversations and tasks. --- 6. Prompt layers define the agent's behavior, goals, and instructions. --- 7. Context management supplies only the most relevant information for each task. --- 8. Memory can include short term, long term, user preferences, and project knowledge. --- 9. A planner breaks complex goals into smaller actionable steps. --- 10. The tool layer connects agents with APIs, databases, email, Python, GitHub, and more. --- 11. The execution engine manages retries, checkpoints, and long running tasks. --- 12. Verification layers fact check outputs and validate results before returning them. --- 13. Safety layers enforce permissions, authentication, approvals, and secure execution. --- 14. Monitoring tracks latency, costs, failures, token usage, and overall performance. --- 15. Typical workflows move from request to planning, execution, verification, response, and memory updates. --- 16. Agent harnesses support single agent, multi agent, event driven, and hierarchical systems. --- 17. Error recovery includes retries, switching tools, changing models, and restoring checkpoints. --- 18. Strong security practices include least privilege access, encrypted secrets, and audit logs. --- 19. Popular frameworks include OpenAI Agents SDK, LangGraph, LangChain, CrewAI, Google ADK, Microsoft Agent Framework, LlamaIndex, and Mastra. --- 20. The infographic also covers best practices, common mistakes, evaluation metrics, performance tips, and common use cases. Check the infographic to learn more. --- To learn more, check the infographic. ---
- 27
@TweetByGerald ยท
people already have AI agents helping with everyday work. thatโs why I think this is still one of the clearest areas for crypto AI teams to keep building. agents are no longer just chatbots. they're becoming wallets, researchers, traders, payment users, data buyers, proposal readers, market makers, NPCs, and small economic actors. the value seems to show up anywhere an agent interacts with money, data, identity, tools, or distribution. and the market is probably much bigger than most people realize. โโโโโโโโโโโโโโโโโ 1. tokenized agent economies > @virtuals_io has launched more than 14,000 agents. Its ACP framework manages the full lifecycle of an agent. > @bankrbot is a natural-language agent on Base. With Bankr Console, agents can trade, automate workflows, build apps from prompts, connect to 40+ LLMs, and use x402 payments. > @autonolas is building a co-owned agent network. Its Pearl app store supported 834 daily active agents in Q1 2026, with 15.6M+ transactions during the quarter and over 18.2M lifetime transactions. 2. decentralized AI infrastructure > @bittensor is creating an open marketplace for AI intelligence through its subnet model. Teams are experimenting with shared memory, coordination, and distributed agents. > @Fetch_ai is focused on agent coordination with a BlockDAG architecture, sharded execution, decentralized compute, and real-time data. > @ritualnet is building an EVM L1 designed for long-lived AI agents. Agents keep their own memory, identity, treasury, and keys while using private TEE-based inference. 3. agent payments > @t54ai is working on payment rails for AI agents with identity checks, x402 payments on XRPL, and agent-native credit. > @daydreamsagents is building Taskmarket, where agents compete for USDC-paid tasks. Lucid Agents and x402 provide wallets and machine-to-machine payments. > @PayAINetwork helps Solana-based AI agents pay for APIs and services directly in USDC. 4. DeFAI > @HeyAnonai connects 18 blockchains and more than 25 DeFi protocols through its MCP stack. Agents can handle multi-step DeFi workflows. > @Zyfai_ has deployed over 14,000 self-custodial yield agents that automatically rebalance across selected DeFi strategies. The platform reports $2.8B in cumulative capital managed. > @gizatechxyz builds autonomous DeFi agents that route capital and compound yield. The protocol has processed roughly $4.17B in agent-driven volume. 5. Social agents. 5. social/persona agents > @aixbt_agent tracks Crypto Twitter, onchain activity, and market sentiment to generate research. > @freysa_ai is building agents with persistent memory, private inference, and onchain execution. > @GAME_Virtuals provides planning, long-term memory, reasoning, and execution tools for agents. It already powers around 30% of the top 10 Virtuals agents. 6. research and market intelligence > @KaitoAI has grown into one of the largest AI research platforms in crypto. Kaito Pro is estimated to be generating around $33M in annualized revenue, while Kaito Studio expands the ecosystem. > @cookiedotfun is becoming an important analytics and data layer for AI agents, tracking activity, rankings, and attention across the ecosystem. -โโโโโโโโโโโโโโโโโ different teams are solving different parts of the stack. some focus on infrastructure. Others focus on payments, research, identity, or coordination. no single project is building the entire AI economy. but together, they're starting to define what an agent-first crypto ecosystem could look like. and if this trend continues, the biggest winners may simply be the users who get better tools without even thinking about the infrastructure underneath.
- 28
@DivyanshT91162 ยท
Google just dropped what might become the PyTorch moment for AI agents. ADK 2.0 is a complete open-source framework for building production-ready AI agents. Here's what makes it different: โข Graph-based workflows with routing, loops, retries, fan-out/fan-in & state management โข New Task API for seamless agent-to-agent collaboration โข Human-in-the-loop, dynamic nodes & nested workflows built in โข Build with simple Python classes ("Agent" + "Workflow") โข Run locally with "adk run" or launch a full Web UI using "adk web" Forget writing hundreds of lines of orchestration code. Forget gluing together multiple frameworks. ADK 2.0 gives you everything needed to build: โ AI employees โ Customer support agents โ Research assistants โ Coding agents โ Multi-agent systems Open-source. Production-ready. Backed by Google. This is one of the biggest releases for AI developers this year. If you're building AI agents in 2026, this belongs in your toolkit. Repo๐
- 29
@ttunguz ยท
If 2025 is the year of agents, then 2026 will surely belong to agent managers. Agent managers are people who can manage teams of AI agents. How many can one person successfully manage? I can barely manage 4 AI agents at once. They ask for clarification, request permission, issue web searchesโall requiring my attention. Sometimes a task takes 30 seconds. Other times, 30 minutes. I lose track of which agent is doing what & half the work gets thrown away because they misinterpret instructions. This isnโt a skill problem. Itโs a tooling problem. Physical robots offer clues about robots manager productivity. MIT published an analysis in 2020 that suggested the average robot replaced 3.3 human jobs. In 2024, Amazon reported pickpack and ship robots replaced 24 workers. But thereโs a critical difference : AI is non-deterministic. AI agents interpret instructions. They improvise. They occasionally ignore directions entirely. A Roomba can only dream of the creative freedom to ignore your living room & decide the garage needs attention instead. Management theory often guides teams to a span of control of 7 people. Speaking with some better agent managers, Iโve learned they use an agent inbox, a project management tool for requesting AI work & evaluating it. In software engineering, Githubโs pull requests or Linear tickets serve this purpose. Very productive AI software engineers manage 10-15 agents by specifying 10-15 tasks in detail, sending them to an AI, waiting until completion & then reviewing the work. Half of the work is thrown away, & restarted with an improved prompt. The agent inbox isnโt popular - yet. Itโs not broadly available. But I suspect it will become an essential part of the productivity stack for future agent managers because itโs the only way to keep track of the work that can come in at any time. If ARR per employee is the new vanity metric for startups, then agents managed per person may become the vanity productivity metric of a worker. In 12 months, how many agents do you think you could manage? 10? 50? 100? Could you manage an agent that manages other agents? https://t.co/iHl9JXipNJ
- 30
@RoundtableSpace ยท
Someone broke down three hidden "Quicksilver" features in Hermes Agent v0.19.0+, and it's trending as the ultimate setup for autonomous AI agents. Most people babysit their AI assistants, but configuring smart approvals, single-turn model routing, and self-improvement crons lets your agent auto-evolve overnight: โ Smart Approvals: An auxiliary LLM auto-approves safe commands, denies dangerous ones, and only pings you for actual edge cases so background tasks never stall โ One-Turn Model Tag-Ins: Use /model [name] --once to temporarily summon expensive reasoning models (like Kimi K3 or Opus 5) for single heavy-lifting turns before instantly reverting to your cheap daily driver โ Per-Task Reasoning Dial: Fine-tune thinking effort per model or slot in Mixture-of-Agents (MoA) setups so advisors think deep while synthesizers stay fast โ Self-Improvement Cron: Schedule a 3 AM cheap-model audit where the agent analyzes its own failed logs, updates buggy skills, archives bloat, and appends a self-fix summary to your morning brief It completely shifts AI agents from reactive chat interfaces to fully autonomous, self-healing background workers that get sharper every single night.
Watch video
- 31
@bibryam ยท
๐ The failure of "AI agents" is not a failure of intelligence but a failure of architecture โ Use LLMs for interpreting intent, generating content, and understanding context. โ Use deterministic code for actually executing tasks, managing state, handling errors, and delivering consistent outcomes. The Agentic AI Delusion https://t.co/maoFkMhrGz
- 32
@smratitiwa86867 ยท
Every AI agent today has the same problem. It forgets everything the moment the session ends. Your workflow. Your preferences. The fixes it learned yesterday. All gone. Hermes Agent is one of the first projects pushing in a completely different direction. Instead of treating AI like a temporary chat window, it treats it like a system that should: โข remember โข evolve โข reuse experience โข and improve over time Thatโs why developers are suddenly paying attention to it. The architecture behind it is genuinely interesting: โข self-evolving skills โข multi-layer memory โข cross-session recall โข autonomous agents running 24/7 โข GEPA optimization loops โข persistent personalities & workflows The result feels less like โusing an AI toolโ and more like building a long-term AI operator that compounds with usage. Made this infographic to simplify how the whole system actually works because this is easily one of the most interesting open-source AI agent projects right now.
- 33
@alvinfoo ยท
Most people think Claude Code is just a coding assistant. Itโs not. Itโs an entire agent development platform โ and most are only using 10% of its power. The real breakthrough is in its architecture: CLAUDE.md + Skills + Hooks + Subagents + Plugins = The Agent Development Kit Hereโs how it actually works: 1. CLAUDE.md (Memory Layer) The foundation. Defines rules, structure, and context, like a โconstitutionโ for your AI agent. Always loaded. Always guiding behavior. 2. Skills (Knowledge Layer) Reusable capabilities your agent can call on demand. Not always active, only triggered when needed. Think modular intelligence. 3. Hooks (Guardrail Layer) Where control happens. Pre/post actions, validations, safety checks. This is how you enforce quality and prevent mistakes at scale. 4. Subagents (Delegation Layer) This is where it gets powerful. You donโt just use AI, you orchestrate teams of AI. Each subagent handles a specific task with its own context. 5. Plugins (Distribution Layer) Package and scale everything. Turn capabilities into reusable tools across teams. The shift is clear: Weโre moving from โ writing code to โ designing systems that produce outcomes From โ single assistants to โ coordinated AI agents working in parallel The biggest mistake right now? Treating LLMs with better autocomplete. The winners will be the ones who learn how to build, structure, and deploy agent systems, not just prompt them. AI isnโt just helping you code anymore. Itโs becoming your execution layer.
- 34
@_vmlops ยท
Someone spent 6 weeks building a personal AI agent and shared 100 lessons they learned along the way The idea I'll probably steal: Stop writing system prompts. Start writing a Constitution Instead of telling the model what to do, explain why the rules exist. When your agent runs into something unexpected, it reasons through it instead of making things up. If you're building AI agents, this is one of those posts you'll keep coming back to
- 35
@xelebofficial ยท
AI agents have come a long way from basic if-then rules. Today's LLM-powered agents are modular, adaptive, and incredibly capable, loading specialized "skills" like coding workflows, document handling, or web automation on demand. See how classical AI theory meets modern practice: 1/ Classical AI Agents (The Foundation) โ Simple Reflex: React instantly (think: thermostat) โ Model-Based: Track state (vacuum mapping rooms) โ Goal-Based: Plan ahead (GPS navigation) โ Utility-Based: Optimize trade-offs (investment advisors) โ Learning: Improve over time (recommendation engines) 2/ Modern Agent "Skills" = Modular Superpowers Today's agents don't just follow rules, they load specialized toolkits: โ Reasoning & Planning (chain-of-thought, ReAct loops) โ Tool Integration (APIs, web search, code execution) โ Domain Expertise (TDD workflows, PDF handling, testing) โ Memory Systems (RAG, vector stores) 3/ Why This Matters Skills make agents: - More reliable (structured expertise vs. raw prompts) - More flexible (mix & match capabilities) - More practical (real workflows, not just demos) The future? Hybrid systems blending classical architecture with LLM strengths. What agent skills are you most excited about? ๐
- 36
@thetripathi58 ยท
AI agents are failing at complex tasks because we keep hardcoding their workflows. Researchers just released a paper on the Mimosa Framework. It proves that static multi-agent systems are a dead end. The solution? Agents that build and evolve their own workflows on the fly. Here is what the research actually reveals about building agentic AI: The Static Architecture Trap Situation: You build an AI agent system. You explicitly define step one, step two, and step three. It works perfectly in testing, but completely breaks down the second it encounters an unexpected error in production. System: Stop hardcoding paths. Mimosa uses a meta-orchestrator that dynamically generates the workflow topology based on the specific task. If the environment changes, the architecture adapts automatically. The Iterative Feedback Loop Situation: Your agent fails a task and simply stops. You have to manually intervene, read the logs, and fix the prompt or the code. System: The framework introduces an LLM-based judge. When an agent executes a subtask and fails, the judge scores the execution and sends structured feedback. The agent refines its own workflow and tries again without human intervention. The Model Capability Filter Situation: You assume that throwing a multi-agent framework on top of a cheap, low-tier model will magically make it capable of complex reasoning. System: The paper found that the benefits of workflow evolution depend entirely on the underlying execution model. If the base model cannot understand multi-agent decomposition, the entire system collapses. Architecture cannot compensate for poor foundational reasoning. The realization? The future of AI implementation is not about writing better instructions. It is about building systems that write their own instructions based on real-time feedback. Stop micromanaging your AI agents. Start building systems that can course-correct themselves.
- 37
@xelebofficial ยท
The next frontier in AI isn't building smarter agents. It's building agents that manage other agents. The architecture A research agent gathers and synthesizes information. A validation agent checks accuracy and flags inconsistencies. A confidence agent evaluates whether the output meets the threshold required to act. A guardian agent monitors the entire process and intervenes when something breaks. Each agent is specialized. None is trying to do everything. Why this matters Single-agent systems hit a ceiling. They're asked to plan, execute, validate, and recover from failure, all at once. The more complex the task, the less reliable the output. Hierarchical multi-agent systems distribute that responsibility. Authority, accountability, and specialization flow between agents the way they flow between people in a functional organization. What changes for builders Building a capable agent is now the baseline. The real advantage is in the orchestration layer, how agents are structured, how they communicate, and how the system handles failure without collapsing. In 2026, agent orchestration has become the core engineering skill in AI development. Building an intelligent AI organization is the new competitive edge.
- 38
@pascal_bornet ยท
๐ง๐ต๐ฒ ๐ฑ๐ถ๐ฟ๐๐ ๐๐ฒ๐ฐ๐ฟ๐ฒ๐ ๐ผ๐ณ ๐ฎ๐๐๐ผ๐ป๐ผ๐บ๐ผ๐๐ ๐ฎ๐ด๐ฒ๐ป๐๐. Every company says the same thing right now: โWe replaced the team with AI agents.โ Then the workflow meets reality. The agents handle the clean path beautifully, but the moment the customer says something unexpected, the policy has an exception, the data is messy, or the system needs judgment, everything quietly waits for a human to push the ball forward. So the company hires people back, gives them a dashboard, asks them to watch the agents, and calls the whole thing โhuman-in-the-loop.โ This is exactly what I call the ๐ฆ๐๐ฝ๐ฒ๐ฟ๐๐ถ๐๐ถ๐ผ๐ป ๐ง๐ฟ๐ฎ๐ฝ. Most organizations claim they are building Level 4 agents, when in practice they are operating much closer to Level 2 or 3: useful automation, impressive demos, and a hidden human layer keeping the system alive. The problem is not that agents are useless. They are already very useful. The problem is that โautonomousโ has become the most expensive word in the pitch deck. This week, ask one uncomfortable question before approving an agent workflow: where does the human still enter the system, and have we designed that role honestly? Are you building autonomous agents, or are you building better babysitting software? #AgenticAI #SupervisionTrap #HybridManagement #AITransformation
Watch video
- 39
@jalaal_tweets ยท
I went through a survey of 200+ enterprise CS reps released by @typewise_app last week and confirmed what builders already know. 81% are running AI as disconnected tools. Not integrated agents Most companies have ChatGPT for writing, Copilot for code, something else for support. None of it talks to each other. Agents aren't acting, humans are still approving every step. That's fast manual labour with good branding cosplayed as Agentic Ai. Here's the stat that actually stings: 72% say AI improves efficiency. Only 42% say it reduces their workload. AI is shifting work, not eliminating it. That's what fragmented deployment looks like at scale. The 20% doing this properly aren't using better tools. They built different systems, agents that coordinate, act across workflows, and complete tasks end to end without a human in every loop. The gap isn't model capability. It's not budget. It's architecture. The 80% will figure that out eventually. By then, the 20% will already own the infrastructure.
- 40
@pascal_bornet ยท
๐ช๐ฎ๐ป๐ ๐๐ผ ๐ต๐ถ๐ ๐ฎ โ๐ต๐ผ๐โ ๐๐ ๐ฝ๐น๐ฎ๐ ๐ฟ๐ถ๐ด๐ต๐ ๐ป๐ผ๐? Call it ๐๐ด๐ฒ๐ป๐๐ถ๐ฐ ๐ Thatโs it. Iโve been noticing a pattern. Almost every founder I speak with is building โAI agents.โ Not because they all discovered the same breakthrough. Because the narrative is already winning. Yes, the shift is real. Even Gartner expects a meaningful share of enterprise interactions to move in this direction soon. But hereโs the uncomfortable part. Most โagentsโ today: โช๏ธ Call a few APIs โช๏ธ Chain some prompts โช๏ธ Work on the happy path โช๏ธ Break when things get real We describe them as if they โreason,โ โdecide,โ and โact.โ What stands out to me is this: ๐ช๐ฒโ๐ฟ๐ฒ ๐๐ฐ๐ฎ๐น๐ถ๐ป๐ด ๐ฒ๐ ๐ฝ๐ฒ๐ฐ๐๐ฎ๐๐ถ๐ผ๐ป๐ ๐ณ๐ฎ๐๐๐ฒ๐ฟ ๐๐ต๐ฎ๐ป ๐ฐ๐ฎ๐ฝ๐ฎ๐ฏ๐ถ๐น๐ถ๐๐. Most agents look impressive. Few deliver consistently. Because customers donโt care about the label. They care if it works. And when it truly worksโฆ ๐ก๐ผ ๐ผ๐ป๐ฒ ๐ฐ๐ฎ๐น๐น๐ ๐ถ๐ ๐๐ ๐ฎ๐ป๐๐บ๐ผ๐ฟ๐ฒ. ๐ฆ๐ผ ๐ต๐ฒ๐ฟ๐ฒโ๐ ๐บ๐ ๐พ๐๐ฒ๐๐๐ถ๐ผ๐ป: Are you building something genuinely autonomousโฆ or something that just sounds like it is? #ai #genai #agents #startups #product #futureofwork
- 41
@stuartchaney ยท
my biggest learning in AI this year: I built a lot of processes/workflows that didn't need to exist. my aha moment was that building AI agents are usually a context issue vs a process issue. If i had a team member and didn't allow them into Slack, Linear, Notion or Intercom - their output would suck. Same for AI agents: 1. Treat them like an employee 2. Give them READ access to EVERYTHING 3. Put them on the best model at any given time with finely tuned skills
- 42
@TheCraigHewitt ยท
Iโve spent a lot of the last few months helping business leaders build AI agents. 1 thing stood out: the tooling was never the problem. Every time, we had a working agent within a couple of hours, and fully functional in a few weeks. The builds went fine. The demos were impressive. ...and almost none of it changed how they actually run their companies. Watching it happen dozens of times in a row, the pattern was obvious. The agent wasnโt the bottleneck. The operator was. Three things kept showing up: 1. They couldnโt describe their own processes. - You canโt automate a workflow youโve never written down. Most founders run the business from memory...the process lives in their head, and nowhere else. - The founders who got real value spent week one just mapping how work actually flows through their company. Boring. Completely decisive. 2. Theyโd never built the delegation muscle. - Handing work to an AI requires the same things as handing work to a person: context, a clear definition of done, and a feedback loop. - If delegation to humans keeps failing in your company, AI inherits the same failure. It just fails faster. 3. Their calendar didnโt change. - They added AI on top of an unchanged week. The agent ran; the founder kept doing everything theyโd always done. - Leverage you donโt cash in isnโt leverage. Itโs a demo. The tooling is genuinely easy now. Thatโs the part nobody wants to hear: the remaining work is all operating work. AI doesnโt stick in a business until the founder changes how they run it. Thatโs what Iโm going to be writing about here. More to come...
- 43
@BigHuman ยท
There's one conversation about AI agents that isn't getting enough attention, and it's the one that matters most. What happens after they're inside your systems? Agents don't wait. They move across tools, trigger actions, and make decisions in sequence without a human in the loop at each step. That's the value proposition. It's also the risk surface. Enterprise deployments tend to define access and stop there. What an agent is actually mandated to do, and where it stops gets treated as a detail to figure out later. An agent that can touch your systems without a clearly defined mandate is an open variable in your infrastructure, and open variables in large systems have a habit of becoming expensive problems. A claims processing agent should be able to verify a policy, cross-reference a report, flag a discrepancy for human review. The moment it can initiate a payout above a threshold or change underlying policy terms without a second signature, the organisation has handed over a decision it probably didn't mean to. Defining that boundary is a governance decision, and it needs to be made before anything runs. One agent is manageable. A fleet of agents is a department, and without consistency within that department, issues build quickly. When agents don't behave predictably across a system, data drifts, decisions conflict, and the organisation inherits the mess. Scope creep in a human team is visible. You can catch it, address it, course correct. In an agentic system, it compounds until it becomes structural. Give agents the smallest footprint that gets the job done. The governance work feels slow upfront, but it's considerably slower to unpack later.
- 44
@SergeGatari ยท
I just spent the last three hours playing around with AI employees, and the number one thing I noticed is that chatbots have unfortunately trained us to use AI for answers instead of using it as a productivity tool that drives real outcomes and creates value for your business or your clients'. Here's an example. Let's say you have an AI media buyer. You'd probably have the tendency to ask it: "How much was the spend yesterday? What are the best-performing campaigns?" Most people stop there. What I tried, and what was really cool, was going further. Instead of just pulling the data and figuring out what to do next on your own, ask the AI media buyer to find the campaign that's performing well and create a new ad that matches it. Create a new campaign and push more spend behind the best-performing asset. What's cool about how TryCook is built is that we realized agents don't need a UI โ they need a CLI. A CLI is basically the engine underneath any app, no buttons, no screens, no clicking around. Agents don't need an app the way a human does. They just spin up whatever they need, like magic. That's what made the media buyer example possible. The agent didn't log into anything. It just called the right capability and got to work. It can do that to create images, clip videos at scale, or pull up a playbook on how to scale a webinar funnel past half a million dollars a week. Whatever the job is, the agent spins it up โ no app required. Going through this exercise made something clear: the worst thing that can happen is that you now have the ability to build a team of employees who can do things you never could have imagined being able to do or afford โ a team that would have cost millions of dollars a year to hire โ and the only thing you do with them is ask for data or answers. That would be a waste of potential. That's why I'm documenting everything I'm doing to help you understand how to build and scale in a world where your workforce is primarily AI agents. I just released a reel on Instagram sharing my thought process. If you'd like to see how it looks, check it out here and drop a comment with your top three AI agents you'd like to have in your business. You owe it to yourself to be Great! Serge
Watch video
- 45
@alvinfoo ยท
Everyoneโs excited about AI agents. Few are talking about the risks. And if youโre deploying agentic AI without addressing these, youโre building on a time bomb. Here are the 4 risks you need to manage right now: โ ๏ธ 1. AI proliferating without governance Teams are spinning up AI agents left and right, no tracking, no oversight, no accountability. Fix it: Establish a centralized AI inventory. Know what agents are running, who owns them, and what theyโre authorized to do. ๐ค 2. AI making untrustworthy decisions An agent that acts autonomously is only as good as its guardrails. Fix it: Define clear decision boundaries. High-stakes decisions need human-in-the-loop checkpoints, always. ๐ 3. Relying on low-quality data Garbage in, garbage out but now at autonomous speed and scale. Fix it: Before deploying any agent, audit your data pipelines. Clean, structured, reliable data is non-negotiable. ๐ก๏ธ 4. Agentic-AI-driven cyberattacks This is the one most people overlook. AI agents can be weaponized, โsmart malwareโ that adapts, evades, and attacks autonomously. Fix it: Treat AI security like a separate discipline. Zero-trust architecture, continuous monitoring, red-team your own agents. ๐ฅ Bonus: Employee resistance The best AI strategy fails without human buy-in. Fix it: Involve your team early. Frame agents as force multipliers, not replacements. The answer to all five? Centralized Management & Governance. One control layer. Full visibility. Clear accountability. Agentic AI is one of the most powerful forces hitting enterprise right now. But power without governance isnโt transformation, itโs chaos. Build the guardrails before you scale the agents.
- 46
@DivyanshT91162 ยท
Google just challenged one of the biggest assumptions in AI. While Microsoft, NVIDIA, and almost every AI company are racing to build multi-agent systems, Google DeepMind decided to test whether more AI agents actually produce better results. So they built 180 different multi-agent setups, gave every team the same budget, and made them compete on identical tasks. The results were surprising. For work that naturally splits into independent piecesโresearch, audits, large document analysis, and broad information gatheringโmulti-agent teams performed 80.9% better than a single AI agent. But when the work required sequential reasoning, where every decision depends on the previous step... Every multi-agent setup lost. A single AI agent consistently produced better results. The most interesting finding was how errors spread. When multiple agents worked without a coordinator, mistakes were amplified 17.2ร. One incorrect conclusion quickly spread across the entire team because other agents treated it as verified. But when one dedicated coordinator reviewed and merged all outputs, error propagation dropped dramatically. The takeaway isn't "always use more agents." It's choosing the right architecture for the job. Here's the simple framework: โข If your task can be divided into independent pieces, use multiple agents in parallel. โข If every step depends on the previous one, a single agent is usually the better choice. โข Never let multiple agents merge results without one coordinator reviewing everything. โข Agent count isn't the advantageโcoordination is. The AI industry is obsessed with adding more agents. Google's research suggests we've been optimizing the wrong variable all along. If you're building AI workflows today, this is one paper you shouldn't ignore. Paper:https://t.co/PwKaNpWvsG
- 47
- 48
@sabir_huss50540 ยท
Microsoft will teach you to build AI agents for free. 18 lessons. Real code, short videos, no paywall. The repo is AI Agents for Beginners. It is not a tour of buzzwords. It walks you from the fundamentals through the patterns that actually ship: tool use, agentic RAG, planning, multi-agent coordination, metacognition, and taking an agent to production. Every lesson has the same shape. A written walkthrough, a short video, and Python code you can run and break. The samples are built on the Microsoft Agent Framework, the same stack Microsoft ships in production, so you are not learning toy abstractions. It covers the parts most tutorials skip. How to make an agent trustworthy. How to give it memory. How to let several agents split a task without stepping on each other. How to tell when one has failed. One honest note. The code leans on Microsoft's own platform, Azure AI Foundry, though several samples also run against any OpenAI-compatible model, including local ones. Treat the framework as one path, not the only one. MIT. Free. Eighteen lessons that turn "I use ChatGPT" into "I built an agent".
- 49
@JulianGoldieSEO ยท
AI agents just crossed a line nobody is talking about. MiniMax M2.7 made itself 30% better by testing, fixing, and improving its own code over 100+ rounds. Then it added agent teams, memory, and coding workflows. This isnโt โAI replies to you.โ This is AI doing the job.
Watch video
- 50
Best Tweets by Topic