Do you ever feel like the AI world has moved forward a little too quickly? You hear about self-healing systems and autonomous agents and start...
Some comments have been hidden by the post's author - find out more
For further actions, you may consider blocking this person and/or reporting abuse
There is a new term every week, it's so hard to keep up. And also some of the terms is so stupid, I dont know who coins them. It took me so long to understand what a harness actually is, the word itself yields a constraint, but I see many people speak philosophically and hypothetically on what these things are.
Thanks for the list!
Thanks! π And you know what? I had trouble understanding what a harness actually was too. The funny thing is, of course you're already using one, whether you realize it or not, if you're building any kind of agent π Maybe itβs just an unfortunate name for something thatβs actually pretty straightforward.
Yes, but it's also the nuance people use the terms, more often than not I try to piece the term from their context π
Exactly! π When I was researching some of these definitions, I kept getting confused because different people seem to understand and use the same terms differently!
Hello. I'm reaching out after viewing your profile. I noticed you have ten years of experience in software development, and I found some common ground with you, as I also have a long background in the software industry.
I'm sending this message in the hope that we might discuss our respective experiences and potentially collaborate on future business opportunities.
Thank you,
Trevor
I tried your prompt: βBuild a base on Mars.β And still no base!
So $10 million is way too much, Iβm offering 100 forints π
π€£π€£π€£ But how do you know, Daniel? Have you been there? Maybe the base is already standing π Come on, at least give me 100 Czech crowns! π€£
I know because the agent wrote: βCurrent status: still no base.β π€£π€£π€£
And as we all know, we should always blindly trust AI. π€£
Hahahaha okay, if the AI says so, then it must be true π€£ In that case, Iβll accept the 100 forints π
Deal! Iβll proceed with the payment once the base is done. π€£π€£π€£π
Okay, Iβve reconsidered, and I think the base is definitely already there and the model is just hallucinating π€£ We all know models are right 99.9% of the time, but thereβs still that 0.1% and this is obviously it π Unless youβre using some really weak model instead of super-new-fable-999-alpha, of course.
I miss the: Agent Footprint
Yes!!! I also realized afterwards that Iβm missing Skillsβ¦ but damn, I already crammed 20 terms into this thing π
Really useful breakdown, especially the distinction between agentic workflows, agent loops, tool calling, and the agent harness.
One point I'd add from an engineering perspective: giving an agent more context and tools doesn't automatically make it safe or production-ready.
The interesting boundary is what happens between capability and authorization.
An agent may be able to:
But the fact that it can perform an action doesn't necessarily mean it should be authorized to perform it.
That's where I think the next layer of agentic engineering is emerging: policy, capability, resource scope, validation, and auditability around the agent loop.
Context engineering answers:
Governance needs to answer:
That distinction becomes increasingly important as we move from AI assistants toward autonomous engineering agents.
Great list β #5 (Agent Harness) and #6 (Context Engineering) especially feel like foundations for this next discussion.
Exactly! This is really the next level after what I cover in this article. Once you understand the basic concepts and how all these pieces fit together, thatβs when the serious engineering begins π Thanks for adding this perspective!
Absolutely β and thank you for the article and for engaging with the discussion!
I think thatβs exactly where the interesting engineering begins: moving from understanding agentic AI concepts to defining the control boundaries that make those agents trustworthy in real systems.
The ideas you covered provide the foundation; what Iβm exploring with NAEOS is what happens when we turn those ideas into enforceable engineering mechanisms β policy, authorization, provenance, side-effect tracking, and independent audit.
Thereβs still a lot to work out, but I think this is where AI engineering starts becoming a real engineering discipline rather than just a collection of agent tools. π
The memory example is the easy half of the term, and it is worth naming the hard half, because the hard half is the reason memory exists at all. Elon asks what he wanted to buy, and the agent finds it, because the question names the thing to look for. Now change the request. Three weeks later Elon says: draft an offer for that coding company, the budget is whatever is left after the rocket. Nothing in that sentence points back at Monday. A memory that only works when the question names the fact will write a perfectly good offer and never bring up the one note that would have earned its keep, the part about how much.
Those are two different abilities, and they are measured separately. A study this summer ran one memory system on both. Asked directly, it found the stored fact every single time. When the later request merely depended on the fact without naming it, the fact made it into the answer roughly one time in ten. Same store, same facts, different shape of question.
So the test for whether memory works is not the one in the article, although that one has to pass first. It is this: ask the agent for something that depends on what it knows, without telling it what it knows, and check whether the answer changed. If the answer is the same one a stranger would have written, the store is full and the memory is not working.
Thanks for this comment, and yes, exactly! I presented the basic version of memory here, but as you point out, that's actually the easiest case: the request itself tells the agent what information to look for. The implicit case, where the agent has to recognize on its own that some previously stored information is relevant, is much harder. Thanks for adding this nuance! π
The implicit case is where the interesting measurement problem sits too, not only the interesting engineering problem. If you score the final answer alone, a model that gets it right from general knowledge scores the same as a memory that actually delivered, and both read as a win. The cheapest correction I know is a second copy of the same starting state with the decisive fact removed, or replaced by a decoy of the same shape and length. What you report is then the difference between the two runs rather than the score of one, and nothing has to be inspected inside the retrieval step.
It catches the opposite failure as well. A system that fires on every request, including the ones the stored fact should not touch, looks strong on the cases where the fact was relevant and quietly costs you everywhere else. The difference between the two copies is the only number I have found that moves for one of those and not the other.
The Elon MΓ³zg framing made this such a fun and refreshing read!
The distinction you drew between the model and the Agent Harness in #5 is the exact line separating brittle prototypes from production systems.
A lot of tutorials still treat the LLM as if it should own the state machine itself. But because LLMs are probabilistic, giving them ownership of external execution state is dangerous. If a tool call or MCP transport connection times out, handing that ambiguity back to the model usually causes it to either optimistically hallucinate success (the classic "green trace" that actually failed) or initiate blind retries that double-charge a card or spam a database.
The harness has to be the deterministic adult in the room: treat the model as a pure transformer (
Context -> Intent), intercept the tool execution, record an idempotent intent receipt, and verify the post-condition state before handing control back to the next turn.Good luck at AGNTCon + MCPCon Europeβstandardizing the boundary between MCP interfaces and deterministic execution harnesses is right where the field needs to head.
Thanks for this fantastic comment! I agree with every word. And my AGNTCon demo actually illustrates exactly this problem. Itβs a slightly tongue-in-cheek βAI CEOβ where you can fire half the company with a single prompt π Of course, itβs deliberately designed that way to highlight precisely how dangerous it is when you give the model too much control over execution.
And I can definitely tell this comment comes from someone who has dealt with this stuff in practice π
my kinda post, I am so falling behind on these terms haha
Hahahaha right? π I basically skipped the first six months, maybe even a whole year, of the AI revolution. And somehow missed absolutely nothing, because half the stuff from a year ago is already outdated anyway π
Great simple breakdown! Really helps clarify the difference between agent loop, workflow and MCP. Iβve been messing around testing local agent setups on my laptops lately π And if Skynet ever does activate, I hope a Schwarzeneggerβstyle robot comes to rescue me, hahaha.π€£
Thank you so much!!! π Hahaha exactly, if weβre getting robots, I want the Schwarzenegger kind π But before Skynet happens, can someone please invent a robot butler that does absolutely everything around the house, like in The Jetsons? Thatβs the AI revolution Iβm actually waiting for π€£
If I could pick another robot, Iβd go for Doraemon, hahaha π
Hahahaha Iβm crying π Then Iβd also like to request Optimus Prime to dig up my garden π€£
The βcontext engineeringβ part really resonates. I think document changes are an underrated piece of context too β especially when an agent is working with multiple versions of the same PDF or specification.
Itβs not always enough to give the agent the latest file; knowing exactly what changed between versions can be just as important. Great list overall, especially for developers trying to get their heads around all these new terms.
Thank you, exactly! There are so many nuances to all of this. And I really like your PDF example because it perfectly shows that context engineering isnβt about throwing as much context as possible at the agent. Itβs about giving it the right context.
'Elon... That's a chatbot', probably the most on the nose reference of them all π Cant argue with it, he does tend to oversell and under deliver quite alot... Especially when it comes to level of autonomy (cough cough, autopilot)
Hahaha, looking at modern tech companies, I donβt think heβs the only one π I used to work at a startup where the woman writing the user documentation would go directly to the developers to ask how the product actually worked and what it could really do, because management was basically selling her a spaceship π
True, very true
This article provides a fantastic, accessible breakdown of agentic AI concepts. The distinction between agentic workflows and loops, paired with the "Elon MΓ³zg" narrative, makes complex terms like MCP and HITL remarkably clear. Itβs the perfect primer for developers navigating the rapidly evolving autonomous agent landscape. Great read!
Thank you so much! π That's exactly what I was aiming for: to make it possible to actually learn something while having a few laughs along the way. π
The gap between "agent loop" and "agent audit trail" is worth flagging explicitly. When an orchestrator delegates across three agents and each runs its own loop, you end up with a final output but no tamper-evident record of which agent decided what, at which step, on which exact input. Guardrails (term 15) prevent bad actions, but they don't produce evidence that the right actions happened - which matters the moment you operate in a regulated context: EU AI Act Article 12 requires logging for high-risk AI systems, and "the logs say so" is not the same as a verifiable record. The HITL example captures this perfectly - "human was in the loop" needs to be provable, not just claimed.
Thanks for this comment! This is a great addition, youβve already gone about two levels deeper than this article π And I absolutely agree with the broader point about auditability.
One question though: are you sure Article 12 specifically requires tamper-evident agent audit trails? It definitely requires logging and an appropriate level of traceability for high-risk AI systems, but I donβt think it goes as far as explicitly requiring tamper-evident records. Is that your interpretation of the requirement?
One thing Iβd add is that these terms become much more useful when you start thinking about their boundaries. For example, an agent loop can make decisions dynamically, but the harness still determines what the agent is actually allowed to do. That distinction becomes especially important when debugging failures: was the modelβs decision wrong, or did the surrounding system give it the wrong tool, context, or permission? Separating those layers makes agentic systems much easier to reason about than treating the whole thing as βthe AI.β
Thanks for adding this! And yes, absolutely, that's exactly how it works. π This distinction becomes especially important once you move beyond understanding the basic concepts and start building production-ready agents.
This was a good and education article, really need to explore and revisit some concepts
Thank you so much! π Yeah, things change incredibly fast in this field, so thereβs always something new to explore and revisit.
Great breakdown! The MCP section hit close to home β I build Apify actors that basically function as tools an agent would call. Funny to see it framed from the "agent's perspective" instead of the builder's side for once.
Haha, you're right! π I actually didn't even notice that I was framing it from the agent's perspective while writing it, but now that you mention it. π
Really liked the way you explained these without turning them into overly technical definitions. The MCP vs A2A distinction and the point about context engineering were especially useful. And βagent washingβ definitely deserves more attention π
Thank you! π Weβve actually been joking about agent washing in the comments too. These days someone writes a cool Skill and suddenly itβs an βAI agentβ π
Solid glossary β "orchestration" vs "chaining" is the distinction I see confused most often in production setups.
One thing I'd add from running agents locally: the cost dimension reshuffles which of these terms actually matter. When your "agent" runs on a $20/month API budget, terms like "guardrails" and "human-in-the-loop" stay theoretical. When you run the same loop on a free local model (Ollama + a 4B coder on 8GB VRAM), you start caring about "context window" and "tool calling" reliability fast β because the failure modes are silent, not billed.
I've been tracking which of these terms survive contact with a $0 stack β the answer surprised me (spoiler: "memory" is where free models fall over first).
Which of these 20 do you think matters most for someone building their first agent on free/local models only?
Thatβs a really interesting point, especially "the failure modes are silent, not billed" π
For a first agent running entirely on free/local models, I think Iβd actually pick tool calling. You can start without sophisticated memory, orchestration, or even a huge context window, but if the model canβt reliably decide when to call a tool and produce the right arguments, the whole agentic loop starts falling apart pretty quickly.
And now youβve made me curious about your memory experiments π Why was memory the first thing to fall over for you?
Iβve read quite a few of your articles, and I really enjoy them! Theyβre honestly so much fun to read. While reading, it sometimes feels like Iβm watching a movie or a video rather than reading an article. Your writing style is really engaging and keeps me hooked!
Aww, thank you so much! β€οΈ Thatβs incredibly nice to hear! I always try to make sure my articles not only have something useful to say, but are also genuinely fun to read. So this really means a lot to me π
Its really liked the way you explained these terms without making them feel overly technical. The difference between an agentic workflow and an agent loop was especially easy to understand.
Thank you! π I actually spent a bit more time on that distinction specifically, because I found a lot of conflicting and unclear explanations online. Iβm really glad it came across clearly!
My pleasure mam it definitely did! The simple examples made the distinction much clearer. π
The βagent washingβ point might actually be the most important one on this entire list.
Weβre at the stage where adding βagenticβ to a product description can make a workflow sound 10x more autonomous than it actually is. Speaking from personal experience.
Hahaha exactly π I remember a meme where someone replaced every βLoading...β in their app with βThinking...β and suddenly they had an AI agentic startup π€£
This is fantastic. Many of these are kept coming up as questions. We have a my team TeamOS (team operating system with bunch of skills and agents - I originally wrote it and now people are contributing to it), I got tired of answering at times so I built a /glossary in it :) I know oneβs thinking why canβt people Google or ask in the harness, people do ask. I love it.
Hope you are okay, as I may take this page and import into that glossary as it also has example which may explain better. Thanks for compiling this
Absolutely, and thank you! π Feel free to copy whatever is useful!
And yes, thatβs exactly what Iβve noticed too. We have Google, ChatGPT, all these toolsβ¦ but you still need to know what to ask about in the first place π And even when you do, so many of these definitions are either unnecessarily complicated or so dry that you read them and still have no idea what the thing actually is π
Great glossary "tool receipt pattern" (item 12) is the one I wish more teams knew. Every tool call in reasoning must have a logged execution, or it's hallucination. Added it to my harness as a deterministic pre-check.
Totally agree!!!
Thanks for investing the time and effort to publish this helpful post. It is much appreciated!
Thanks a million π₯°
This is hands-down the most entertaining glossary I've ever read. The Elon MΓ³zg framing is genius β it makes abstract concepts like agent loops and orchestration actually stick. The distinction between agentic workflow and agent loop was the clearest explanation I've seen. Good luck at AGNTCon + MCPCon!
Thank you so much! π And yes, I actually spent a bit more time on the loop vs. workflow distinction, because I feel like there are so many conflicting definitions floating around the internet. π I'm really glad this one made sense and actually stuck!
High quality dictionary - But I'd say; "An AI agent is an LLM with 'tools'", not what you write ...
Thanks! π Iβd say βan LLM with toolsβ is a useful shortcut, but I wouldnβt use it as the definition of an agent. An LLM can have access to tools and simply make a single tool call without operating agentically at all.
For me, the important part is that the system can decide what action to take, observe the result, and continue based on that result toward a goal. Otherwise weβd basically be calling any LLM application with tool calling an agent π
Really useful breakdown of agentic AI concepts, especially the simple explanations of MCP, agent loops, and tool calling. Iβll definitely check out more developer resources on codecan.net as well.
Thanks a million :)
Thanks for sharing ππΌ
That demo sounds hilarious and terrifying in equal measureβthe classic prompt-injection-to-HR pipeline π Hope the AGNTCon talk goes great!
Ah, thanks a million, I hope it'll be fine π
Thanks for this, I am really concerned about the IA evolution and how every day something new happens ahaha
Exactly! π Things are moving so fast that who knows, a year from now, this list might look completely different! π
few useful terms I just learned
Agent washing is becoming a real problem. Iβve seen simple prompt β response flows get dressed up as autonomous agents. The actual execution path tells you much more than the label.
Oh, it gets even better! Sometimes someone writes a single skill and proudly calls the whole thing an AI agent. π
This was so helpful, thank you!
Awww thanks π
Wow
great article, Sylwia.
Awwww thanks, Ben π₯°
Great read! π Its really mind boggling to think where we were just 1 year ago today with the technology.
Absolutely! π I actually mentioned this in another comment, that I pretty much missed the entire first year of the AI revolution, technology-wise, because my company didnβt allow us to use it and I couldnβt be bothered to keep up with it in my free time π And when I finally came back to it a year later, I felt like Iβd missed absolutely nothing because there was already a completely new stack to learn anyway π
The Skynet comparison made me laugh π But honestly, the way AI terminology keeps multiplying, a plain-English refresher is genuinely useful. Looking forward to seeing what you cover on HITL, MCP, and autonomous agents, especially with AGNTCon + MCPCon Europe coming up!
This is a genuinely useful glossary β the MCP section is one of the clearest beginner explanations I've seen. From the Java side, we've been wrapping MCP servers/clients into plain annotations (@McpServerEndpoint / @ToolMapping) so a Java method becomes a tool without manual protocol handling. Posts like this make it much easier to explain why that matters. Bookmarked for our docs' "further reading" list.
The cost breakdown here is exactly what I needed to see. I've been running a similar setup with local Ollama models as the fallback and it cut my monthly API spend from ~$180 down to about $12.
One thing that surprised me: the biggest savings wasn't the model itself, but the retry/fallback ordering. Putting a 3B local model as the first-pass filter before hitting any paid API dropped my token usage by ~70%.
Have you experimented with routing logic based on prompt complexity, or is it mostly manual fallback chains at this point?
One thing that becomes clear once these concepts move from theory into production is that they aren't really independent building blocks. At IT Path Solutions, we've seen how memory can affect planning, tool access can change the level of autonomy, and observability determines whether you can actually understand what happened afterward. The tricky part is defining clear boundaries between these pieces. An agent can have all the right components and still be unreliable if there is no way to verify what happened at each boundary. That connection between terminology and real operational behavior is where these concepts become much more useful for developers.
Agent washing has a marketing cousin worth naming: every agency that renamed its SEO page to GEO in 2025 without changing a single thing about the work. Same deliverable, new noun, higher retainer. Your Glokzilla Ultra bit is the exact conversation, just with an account manager instead of a developer.
Sex Toys buy online store in pakistan
BDSM Toys buy online store in pakistan
Dildos Buy online store in pakistan
Vibrators buy online store in pakistan
Chastity Cage buy online store in paksitan
Strap-on Dildo buy online store in pakistan
Butt Plugs buy online store in pakistan
Sex Doll buy online store in pakistan
Pocket Pussy buy online store in pakistan
Penis Sleeves buy online store in pakistan
sex sofa buy online store in pakistan
Online Toys - Shop Your Desired Sex Toys in Pakistan
Female Vibrators Toys Online Pakistan - Online Toys
Dildos Toys For Men Online Pakistan - Online Toys
Butt Plugs Toys For Women Online Pakistan
Sex Dolls For Men Online Pakistan - Online Toys
Chastity Cage For Men Device - Online Toys
Penis Sleeve Dildo For Men Online Pakistan
Pocket Pussy Toys For Men Device - Online Toys
BDSM Toys For Women Online Pakistan
Sex Sofa For Couple Toys Online Pakistan
Hy job seekers check our website