IBM engineers just released a 40-minute deep dive into “Agent Engineering” for building production-ready AI agents “80% of building an AI agent has nothing to do with the model. It is frameworks, tools, skills and risk controls.” 00:00 - the 5 core concepts behind every AI agent 11:07 -... choosing frameworks for tools, memory and orchestration 23:01 - when agents need MCP, skills or both 31:04 - designing AI architecture around real production risk The core stack: Agent → Framework → MCP → Skills → Risk → Production This 40-minute workshop will teach you more about production AI agents than most $500 Agent Engineering courses. Watch it today, then read the full agent engineering playbook in the article below ↓show more

that's what i find, thanks

enjoyed

@0xMorlex honestly didn't realize how much goes into the non-model stuff. makes you appreciate the work behind "just throw GPT at it" solutions lol

That 80% number tracks. Of our ~110 scheduled jobs, maybe 15% is prompts/model — the rest is retries, idempotency, and knowing when to page a human instead of quietly failing.

Morlex, new alpha every day. how you find this info?

a lot of in gpt mate

40 分钟有点长，但这几个点还挺适合跳着看

This tracks hard. Most people still treat agents like “better prompts + tools”. In production the real work is: • retry & idempotency logic • clear failure modes • knowing when to escalate to a human • cost + latency observability The model is maybe 15-20%. Everything else is systems engineering.

That 80% line is the part people underestimate. Models matter, but the behavior layer around tools, memory, guardrails, incentives, and recovery is what decides whether an agent survives real use.

The 80/20 split tracks with what actually breaks: rarely the model, usually the retry loop around a flaky tool call. How to Actually Debug Agent Failures: 5 Harness Checks a Bigger Model Cannot Fix

80% frameworks, 20% model — and 100% of that framework is 'what did you actually want'

The "building an agent is mostly not the model" framing is exactly right, yet everyone who starts one learns it late. For us the recurring killer is state and permission edges, not prompts. Curious - in that deep dive, do they weight the control loop and observability above memory design?

if it doesn't save time in a week I cut it

this matches what i see building plugins on the side. the model call is like 10% of the actual work, rest is glue code and edge cases

that's a tough pill to swallow. i bet most devs would swap 20% of their model expertise for 10x better risk management skills

The 80% figure is right, and in legal it's closer to 95%. Nobody cares that a model can draft a clause, they care whether it followed your playbook and caught the term that kills the deal. Risk controls aren't a wrapper round the product at @GenieAI, they are the product.

The 80% is tools, frameworks and skills, exactly. That is the whole reason Even exists, the model is the commodity, the environment around it is the moat.

This is what I did to manage agentic AI with graph

80 percent not being the model is a pretty important reality check lol. tools skills and risk controls are where the benchmark gets interesting 🤖

risk controls are where most agent demos fall apart

the "80% is not the model" line is the part most teams learn the hard way. tooling and guardrails are where production agents actually live.

80% of agent engineering really is risk controls and harnesses. if your agents can grep master env files, prompt guardrails are completely useless.

This matches what I’m seeing in practice. Once the model is good enough, the real work shifts to tooling, memory, and risk controls.

The 80% outside the model is where agents usually die: permissions, tool failures, evals, and rollback. A clean framework diagram is easy; proving the system fails safely is the real production work.

80% of building an agent has nothing to do with the model. Same goes for life's biggest decisions. They're rarely clear-cut. Most are 51/49 calls where frameworks narrow the field but you still have to leap.

The security case lives in that 80% too. An agent's blast radius is the union of the permissions its tools carry, which is decided in the plumbing rather than in the model. Blockaid's H1 report already logs a prompt injection that reached a crypto agent's payment authority.

I spent about a day picking the model for my agent setup and weeks getting the scheduler, retry logic, and context passing to actually work reliably.

the model still matters at the failure edges, but most production pain really is outside it. the expensive bugs are usually state, recovery, tool permissions, and evidence: what woke the agent up, what changed, what it tried, and whether someone can safely resume the work.

Nothing to do with the model" is a useful correction but it overcorrects. The 20% matters a lot when your use case is domain-specific. I spent weeks tuning Grok with x_search for pharma/regulatory signal detection. The tooling was trivial compared to figuring out which model actually understood SFDA terminology without hallucinating.

Putting risk before production made me grin 🙂 It’s a small ordering choice, but an honest one for anyone trying to ship agents.

The 80% point resonates: production reliability usually lives in tool contracts, permissions, observability, and recovery paths. A capable model can still fail if the surrounding system cannot explain or contain its actions.

That 80% stat hits. Everyone fixates on models but the plumbing matters more once you actually ship something.

IBM says 80% of agent engineering isn't the model. What they don't say: the other 20% fails when you only speak one language. Rigid logic breaks. Ungrounded intuition drifts. The bridge is where production systems actually work.

Tool access is half the job. Publish from the user's own logged-in machine. PublishPort:

That 80% estimate matches what breaks first in production: tool contracts, retries, permissions, observability, and cost controls. Model choice is one layer.