What Are AI Agents in Practice, Really?

AI agents in practice are software entities whose core decisions come from an LLM instead of hardcoded if/else branches. In a June 2025 demo, Full Cycle instructor Wesley Willians shows a five-agent system that reads application logs, files a GitHub issue through a GitHub MCP server, and notifies a Discord bot with the link.

AI Agents in Practice: What Makes Software an Agent

An AI agent is ordinary software with one structural difference: the LLM, not a decision tree, sits at its core and makes the decisions. Wesley Willians, the Full Cycle instructor, defines it in his June 2025 video as a software entity with its own behavior, a clearly defined role, knowledge of its environment, and access to tools. The full walkthrough lives on the Full Cycle YouTube channel, and the school behind it is Full Cycle.

That definition has practical consequences. A traditional service follows deterministic paths: run this, catch that error, fall back to the other branch. An agent improvises. It can query a search engine, hit a custom tool that reads a company database, or ask another agent for help, choosing per problem.

Three properties from the video matter most for anyone studying AI agents in practice:

• Unstructured input. The agent accepts JSON, markdown, or free text and interprets intent, where a conventional service would need regex and parsers.

• Short- and long-term memory. It keeps the current session's state and can consult previous sessions, so a returning customer or a recurring bug meets an agent that already has context. In the instructor's customer-service example, the agent remembers a caller who always asks for discounts and declines to repeat one.

• Tool use within its role. The agent knows what it is allowed to do and picks tools accordingly, from web lookups to internal APIs.

What an Agent Is Not: RAG, MCP and Chatbots

Four common identifications are wrong, and the video spends real time correcting them. An agent may use RAG, call MCP servers, or sit behind a chatbot interface, but none of those pieces alone makes software an agent. Knowing the boundaries keeps the architecture honest when you design your own pipeline.

• LLM plus business rules is not automatically an agent. A conventional application can call a model to evaluate one rule and stay a normal application. Agency comes from autonomous decision-making, not from a model call.

• RAG is not an agent. Retrieval-Augmented Generation chunks documents, stores them in a vector database, and retrieves passages at query time. An application can use RAG without any agency, and an agent can use RAG as one tool among several.

• The Model Context Protocol is not an agent. MCP is a protocol that lets models reach external tools, resources, and prompts; Anthropic publishes the Model Context Protocol specification. The demo's agents use MCP servers for GitHub and Discord.

• A chatbot is not necessarily an agent. A chatbot can host an agent behind its interface, but most current agents have no visual interface at all; they talk to other agents to finish their work.

How Multi-Agent Systems Delegate Work

A multi-agent application assigns each agent a specific task, and the agents hand work to each other until the task is done. The video stresses delegation as the defining behavior: an agent finishes its part and passes the result onward, and the call order emerges from the work itself rather than from a fixed script.

Several mechanisms make this workable in production, according to the walkthrough:

1. Agents talk to each other in natural language, so a request literally reads "check whether this log is an error log."
2. Agents can use other agents as tools, the way a developer might ask a colleague for a draft.
3. An orchestrator agent can enforce order, running sub-tasks sequentially, in parallel, or in explicit loops.
4. Agents can share state, so one agent reads another's processing results.
5. Agents can produce artifacts, such as a markdown file one agent saves and another consumes by reference. The video's example: one agent screenshots a screen, converts it to markdown, saves that file as an artifact, and a second agent picks it up by number.
6. A human-in-the-loop approval step can be inserted wherever the risk warrants it.

Which Frameworks Build AI Agents Today

Five established frameworks can build AI agents today, and Python remains the dominant language for all of them. Each occupies a different point on the determinism-versus-autonomy spectrum, so the choice depends on whether you need a fixed chain, a graph workflow, or free conversation between roles.

Framework	Owner	Best fit
LangChain	LangChain	Chains and deterministic sequences of model calls
LangGraph	LangChain	Node-based workflows with explicit, controlled branching
CrewAI	CrewAI Inc.	Role-based crews of agents with task entities
Google ADK	Google	Agents with sub-agents, workflows, built-in eval and observability
AutoGen	Microsoft	Agent-to-agent conversation and code exchange

The video notes that Google ADK is new as a public release but was used internally at Google for some time before that, which is the instructor's stated reason for trusting it in production. That characterization is the speaker's own assessment, not an independent benchmark. He also observes that the JavaScript world produces a new agent framework almost weekly, while the five above are the consolidated options.

Why Google ADK Fits This Log-to-Issue Workflow

Google's Agent Development Kit is a framework for building agents and multi-agent workflows, and the entire demo runs on its web UI. The instructor highlights observability as the differentiator: events, per-agent and shared state, generated artifacts, and sessions are visible inside the framework, reducing the need for a separate tracing product such as LangSmith. ADK also ships a CLI alongside the web interface.

Two capabilities deserve attention if you plan something similar:

• Evaluation. ADK includes an eval layer that replays expected conversations and compares them against actual runs, so you can assert that a non-deterministic system still follows the flow you designed before deploying it.

• Trace view. Every LLM call, tool call, and MCP invocation appears in a trace, including the create_issue call and the final Discord notification, which makes debugging a five-agent conversation practical.

Inside the Demo: How Five Agents Turn a Log into a GitHub Issue

The demo system, called Bugfinder, is a root orchestrator agent with sub-agents, each owning one step of the pipeline. Plugged into Elasticsearch, it watches incoming logs and either stops early or runs the full chain. The video was published on June 6, 2025, runs about 32 minutes, and had reached 15,796 views at the time this draft was prepared.

The pipeline works in six ordered steps:

1. Log Receiver accepts the raw log, which may be unstructured JSON or plain text, and passes it along for analysis.
2. Bug Analyzer classifies the log. A feature-flag warning was judged non-critical and the workflow stopped; a database authentication timeout on PostGIS was judged an error and the pipeline continued.
3. Issue Drafter produces a deliberately incomplete first draft of the GitHub issue.
4. Issue Reviewer checks the draft against standards and, by prompt design, rejects the first version to force a refinement pass.
5. Issue Refiner merges the reviewer's requests into an improved draft, and the Issue Creator files it on GitHub through the GitHub MCP server.
6. Notifier sends a Discord message, via an MCP-connected bot, with the issue title, priority level, summary, and link.

The final issue, shown on GitHub, contains the error itself, the technology involved, the context, three candidate solutions, the consequences of leaving the bug unresolved, and a priority label.

From Filed Issue to Automated Fix

The pipeline ends at the issue, but the video points at the next step: coding agents that pick the issue up. With a codebase attached, GitHub Copilot in agent mode, OpenAI's Codex, or Gemini could attempt the fix and OpenAI pull request for review, or in some configurations deploy the fix directly.

The instructor's caveat is the right one: how far you let automation go is a decision about autonomy level, not a technical necessity. A pull request awaiting human review and a fully autonomous deploy are both valid configurations, and the risk profile of the system should pick between them. He draws a parallel to seven years ago, when developers had to learn microservices; he expects agent-building to become the comparable default skill.

FAQ

Is an agent just an LLM with business rules?

No. Calling a model inside a conventional application does not make it an agent. Agency requires autonomous decision-making, a defined role, tools, and knowledge of its environment.

What is MCP used for in this demo?

MCP, the Model Context Protocol, connects the agents to external systems. The demo uses a GitHub MCP server to create issues and a Discord MCP connection to send notifications through a bot.

Do the agents in the demo talk to each other in natural language?

Yes. When the Log Receiver hands work to the Bug Analyzer, the message literally reads as a request to check whether the log is an error log. The agents converse as a human colleague would.

Which frameworks can build AI agents today?

The video names LangChain, LangGraph, CrewAI, Google ADK, and Microsoft's AutoGen, each covered in the comparison table above. Python is the predominant language for all of them, and new JavaScript frameworks appear constantly but are less settled.

Can agents work without any visual interface?

Yes, and the video says most current agents have none. They communicate with each other in natural language and only surface results, such as a Discord message, when the task is done.

What is the Bugfinder pipeline?

A root orchestrator agent with six sub-agents: Log Receiver, Bug Analyzer, Issue Drafter, Issue Reviewer, Issue Refiner, and Issue Creator, plus a Notifier. Each owns one step, from reading a raw log to filing the GitHub issue and sending the Discord notification.

Was the demo tested before deployment?

The video shows ADK's built-in evaluation and tracing features, which replay expected flows and expose every LLM and tool call. The quality of the issue drafts shown is the presenter's own demonstration, not an independent measurement.

What happens after the GitHub issue is filed?

A coding agent such as GitHub Copilot in agent mode, OpenAI Codex, or Gemini can pick up the issue, attempt the fix, and OpenAI pull request. How much autonomy to grant that step is a product decision, not a technical constraint.

Do I need Python to build AI agents?

Python is the predominant language across the frameworks shown, and the instructor calls it effectively unavoidable for this area today. If you already program in another language, he considers Python easy to pick up.

Where to Go From the Demo

The pattern to take away is small and repeatable: one orchestrator, a handful of single-purpose sub-agents, MCP connections to the tools you already use, and an eval suite that pins the expected flow. Readers exploring the Portuguese-language ecosystem around this material will also find related content from Gustavo Dev Doido, including the Bootcamp do Dev Doido and the Crazystack Typescript track at crazystack.com.br, alongside Full Cycle's own MBA in software engineering with AI. Compare a couple of these curricula before committing, since the frameworks they teach differ.

Turn Your Own Walkthrough Into a Written Guide

A 32-minute video like this one holds a complete architecture: definitions, boundaries, a six-step pipeline, and tool choices. That structure survives transcription well, which is exactly the job Skala Blog does. If you record explainers, demos, or interviews on YouTube, paste the URL at Skala Blog, get the transcription, and generate a structured article from it, the way this page was built from the Full Cycle walkthrough.

Source video