Until now, AI-driven automation has focused on creating specialized “assistants”: a chatbot for customer service, a model that generates reports, another one that classifies data. But what if, instead of a single assistant, you could orchestrate an entire team of AI specialists that assign work among themselves, collaborate, and make sequential decisions without human intervention? This is no longer science fiction: it’s called Agentic AI, and it’s redefining what an automated process truly means.

---

1. The Conceptual Leap: From Tool to Agent

The key lies in agency. An AI agent doesn’t just execute an instruction—it perceives its environment (data, outputs from other agents, triggers), defines a goal, and takes actions to achieve it.

Think of the difference between a grammar-checking tool and a professional editor who decides to rewrite a paragraph for greater impact. That’s the shift from tool to agent.

---

2. The Power Is in the Orchestration: A Multi-Agent Flow in Action

This emerges when several agents, each with a specific role, work together. Here’s a concrete example of what could be implemented in process automation:

• Agent 1 (Researcher): Monitors news sources and market alerts. Detects a headline relevant to a client.
• Agent 2 (Analyst): Takes that headline, cross-references internal client data, and generates a brief impact assessment.
• Agent 3 (Strategist): Based on that assessment, decides on the best action: prepare a tailored proposal? Alert an executive? Choose the right path.
• Agent 4 (Executor): Carries out the action: drafts a personalized email, schedules a notification, or creates a task for a human.

This workflow—which once took hours or days of back‑and‑forth—now executes autonomously in minutes, 24/7, thanks to agent orchestration.

---

3. Why This Excites Us: Key Benefits

• Complex Problem Solving: Breaks down solutions into manageable steps, mirroring team-based reasoning.
• Fault Tolerance and Adaptability: If one agent fails to reach a goal, the flow can reroute, request help, or ask for additional data (from another agent or a human).
• Next-Level Efficiency: It doesn’t automate isolated tasks—it automates full cognitive processes. This frees human talent for oversight, creativity, and exception handling.

---

4. How to Start Exploring (Without the Hype Trap)

Building these flows requires a mindset shift. Based on our learning so far, a good starting point is:

• Map an existing process clearly, identifying decisions and branching paths.
• Define clear “roles”: What will each agent do? Specialization is essential.
• Establish a communication protocol: How will data and information be exchanged? (APIs, structured messages, specific formats, etc.)
• Keep humans in the loop: Design checkpoints and supervision moments. Human judgment should remain the ultimate authority.

Agentic AI is not about replacing jobs—it’s about amplifying organizational capabilities so they become more proactive, resilient, and intelligent. We are moving from being tool users to becoming architects of autonomous digital ecosystems.

---

Let me ask you:

• What process in your area do you think would benefit from having an “AI team” working in the background?
• Have you explored tools like Autogen, CrewAI, or any other agent orchestrators using LLMs?

I’d love to read your insights and experiences in the comments.

---

Ricardo F.
Passionate about the practical application of AI to transform business processes. Currently exploring the potential of multi‑agent workflows as QA Automation at Oxigent Technologies.

While working as a CE with a system based on an Event‑Driven Architecture (EDA) pattern, I wanted to evaluate the possibility of using this architecture in more everyday tasks. For this case, I chose a control and attendance system that could be used during dog‑walking days organized by an animal shelter located in San Antonio de Benagéber, Valencia, Spain.

The main idea is to assist in coordinating the walks so that volunteers always know—visually and intuitively—which dogs have gone out, which dogs are currently walking, and any other necessary information to ensure the day runs smoothly.

Basically, the system consists of an entry point that triggers an event. The system then analyzes whether it is an entry or exit event and displays it on a dashboard. Later on, we will go deeper and—if possible—make it more complex. For example, adding the ability to obtain metrics about the walking days and the dogs, or adding warning indicators in case two reactive dogs might go out at the same time.

---

Solution Architecture (General Overview)

Ingestion (Producers):

A single API receives all events (QR, NFC, AI).

Routing (Event Bus):

An event bus classifies and distributes the events.

Logic (Consumers):

A “brain” function processes “Entry” and “Exit” events.

State (Database):

A database stores the current state (INSIDE/OUTSIDE) and timestamps.

Visualization (Dashboard):

The dashboard updates in real time.

---

1. Ingestion: Amazon API Gateway

To prevent the mobile app (used for QR/NFC) or the AI model from connecting directly to the logic layer, I use a single, secure, and scalable entry point.

• Service: Amazon API Gateway
• How it works:
  A REST API is created (e.g., POST /events).
  All devices send a simple JSON payload to this endpoint.

---

2. Routing: Amazon EventBridge

API Gateway performs no computation. Its only task is to pass the event on to the central event bus.

• Service: Amazon EventBridge
• How it works:
  API Gateway places the event into EventBridge.
  EventBridge evaluates the event and decides where to send it based on Rules.

---

3. Logic and State: AWS Lambda + Amazon DynamoDB

This is where the magic happens. EventBridge forwards all events to a “brain” function that maintains the dogs’ state.

• Services: AWS Lambda and Amazon DynamoDB
• Database (DynamoDB):
  A table called EstadoPerros is created.
• Function (Lambda):
  A Lambda function called ProcesarMovimientoPerro is created.
  EventBridge triggers it every time an event arrives.

Lambda Logic:

• IF the event action is "SALIDA" (Exit):
  Process the dog as “going out.”
• IF the event action is "ENTRADA" (Entry):
  Process the dog as “coming back.”

---

4. Visualization: Real‑Time Dashboard

The dashboard must receive changes instantly, without a page refresh.

• Services: AWS AppSync or AWS IoT Core (WebSockets)
• How it works (with AppSync):
  1. EventBridge has a second rule:
     “If an event contains nuevo_estado…”
  2. The target of this rule is AppSync.
  3. The dashboard uses the AppSync client library to subscribe to updates.
  4. When AppSync receives an event like:
     {"id_perro": "p-001", "nuevo_estado": "FUERA"}
     it sends it via WebSocket to all connected dashboards.
  5. The dashboard updates the icon for p-001 to “OUTSIDE” in real time.

---

5. Total Time Calculation

To track information for the day:

• tiempo_paseo_total_hoy is already being calculated and stored in DynamoDB each time a dog returns from a walk.
• When the dashboard loads for the first time, it simply queries DynamoDB (via API Gateway) to retrieve the current state and total time for all dogs.

---

Additional Task: Daily Reset

I need a way to reset the tiempo_paseo_total_hoy counter to 0 every day.

• Service: Amazon EventBridge Scheduler
• How it works:
  A scheduled rule (“cron job”) is created to run every day at midnight.
  The target is a new Lambda function (ResetContadoresDiarios) that scans the DynamoDB table and sets tiempo_paseo_total_hoy = 0 for all dogs.

---

Implementation Notes

Whenever possible, I will use IaC (Terraform) for implementation and commit the code to my GitHub account.

---

Thanks to Oxigent Technologies for providing the resources for this POC.
Thanks for reading this far, and I welcome all suggestions!

Martin P.

In the past decade, blockchain technology has emerged as a revolutionary solution for building decentralized and secure systems. Beyond its association with cryptocurrencies, blockchain offers a vast field of opportunities for developers interested in creating innovative applications.

Blockchain development involves creating and maintaining decentralized applications (dApps) and smart contracts that run on platforms like Ethereum, Hyperledger, and Binance Smart Chain. To work in this sector, it’s essential to master:

• Programming languages: Solidity is essential for Ethereum, while Go, JavaScript, and Python are useful for other platforms. With the recent rise of the Solana ecosystem, Rust has become a highly sought-after language.
• Cryptography: Understanding techniques such as asymmetric encryption, hash functions, and digital signatures is crucial to ensure application security.
• Data structures and algorithms: Familiarity with structures like Merkle trees and consensus algorithms such as Proof of Work (PoW) and Proof of Stake (PoS) is necessary for designing efficient blockchain systems.

Additionally, using specialized tools enhances the development process:

• Development environments: Frameworks like Truffle and Hardhat streamline the compilation, testing, and deployment of smart contracts.
• APIs and libraries: Web3.js and ethers.js enable interaction between web applications and the blockchain.
• Version control systems: Git is indispensable for efficient collaboration and source code management.

Adopting best practices is more important than ever for success in blockchain projects:

• Writing secure code: It’s vital to prevent vulnerabilities such as reentrancy attacks and overflows.
• Thorough documentation: Keeping detailed records of the code and its functionality facilitates audits and future collaboration.
• Rigorous testing: Implementing unit and integration tests ensures the correct functioning of smart contracts.

Blockchain development represents an exciting frontier in technology, offering opportunities to create innovative solutions and transform industries. Mastering technical skills, using the right tools, and adhering to best practices will position developers to lead in this dynamic field. As blockchain adoption continues to grow, those prepared to face its challenges will be in a privileged position to drive the digital future.

-P. Riera

Artificial Intelligence has transformed many industries, and software development is no exception. GitHub Copilot, powered by GPT-4 AI, is a tool that assists developers in many programming languages, making it easier to write code, boosting productivity, and reducing errors.

GitHub Copilot has become an essential tool for development. It quickly and effectively provides real-time code suggestions. This article explores its features, limitations, and the impact it’s having on programming.

What is GitHub Copilot?

GitHub Copilot is an AI tool developed by GitHub in collaboration with OpenAI. It is based on the OpenAI Codex model, which has been trained on publicly available source code datasets from GitHub repositories. Designed to interact directly with code as it is written, Copilot provides suggestions for code snippets, full functions, and even complex algorithms—tailored to the context of the project.

---

Key Features

1. Smart Autocomplete

Copilot suggests complete code snippets as you type, significantly reducing development time.

Example in C#:

// Developer comment: Method to fetch products from a database
public async Task> GetProductsAsync()
{
using var context = new AppDbContext();
return await context.Products.ToListAsync();
}

Copilot will analyze the intent and generate the appropriate code.

---

2. Code Generation from Descriptions

You can write comments in natural language, and Copilot will automatically generate the corresponding code—saving developers from having to write repetitive code.

Example:

// Generate a method that calculates the sum of two numbers

Copilot will generate:

public int Sum(int a, int b)
{
return a + b;
}

3. Refactoring and Optimization

It suggests improvements, analyzes your code, and provides refactorings and optimizations to make it more efficient and readable.

---

4. Support for Different Technologies

Besides .NET and C#, Copilot supports many programming languages, including Python, JavaScript, TypeScript, Ruby, Go, and more.

---

5. Contextual Learning & Repetitive Tasks

As you use Copilot, it adapts to your coding style, analyzes your existing code, and improves its suggestions. It also offers alternatives if it detects code that could be improved.

---

6. Code Explanation

Copilot can explain code line by line, making it easier to understand what it does and helping you learn the language.

Example:

/explain @”^[A-Za-z]{1,3}\d{1,4}$”

Copilot will generate:

The code snippet @”^[A-Za-z]{1,3}\d{1,4}$” is a regular expression (regex) pattern used to validate a specific string format, in this case, a license plate number. Let’s break it down:

^: Asserts position at the start of the string.

[A-Za-z]{1,3}: Matches 1 to 3 alphabetic characters. Square brackets [] define a character class including uppercase (A–Z) and lowercase (a–z) letters. The quantifier {1,3} means this part must occur at least once and up to three times.

\d{1,4}: After the letters, matches 1 to 4 digits. \d is a shorthand for any digit (same as [0–9]). {1,4} indicates it must occur between one and four times.

$: Asserts position at the end of the string. In short, this regex validates strings that start with 1 to 3 letters followed by 1 to 4 digits, with nothing else before or after—ideal for validating alphanumeric license plate formats.

---

7. Project Structuring

Copilot can help organize your code—create folders, organize classes and interfaces, and work with a well-structured project layout.

Example:

/new api

Copilot will generate:

8. Bug Detection and Fixing

One of Copilot’s most useful features is its ability to detect bugs and suggest more efficient and optimized fixes.

Example:

/fix var sortedValues = values.OrderByDescending((value, index) => value * weights[index]);

Copilot will generate:

var sortedValues = values
.Select((value, index) => new { Value = value, Weight = weights[index] })
.OrderByDescending(pair => pair.Value * pair.Weight)
.Select(pair => pair.Value)
.Take(2)
.ToArray();

9. Security and Testing

Even if your code is secure, Copilot can suggest security improvements. It can also generate unit and integration tests—saving time and effort.

Example:

/test Sum

Impact on Programming

GitHub Copilot is changing how programming is done in several ways:

• Improved productivity: By automating repetitive tasks and offering precise code suggestions, Copilot significantly increases developer productivity.
• Accelerated learning curve: Beginners benefit from Copilot’s suggestions to understand syntax, code patterns, and improve their knowledge of languages and algorithms.
• Error reduction: Copilot helps developers avoid common mistakes and ensures code consistency.
• Encouraging experimentation: With Copilot handling boilerplate code, developers can focus more on experimenting and exploring new ideas.

---

Ethical Considerations and Limitations

While GitHub Copilot offers many benefits, it’s essential to keep its limitations and ethical implications in mind:

• Code quality: Copilot’s suggestions aren’t always perfect—it might provide solutions that don’t fit your intended results. Developers should always review and test generated code.
• Copyright concerns: Since Copilot is trained on publicly available code, there are concerns about ownership. A paid enterprise version exists where Copilot doesn’t share or store code externally, helping maintain security and privacy.
• Over-reliance: Developers should avoid becoming too dependent on Copilot, as it may hinder the development of their own programming skills.

---

Conclusion

GitHub Copilot represents a significant advancement in AI-assisted programming. Its ability to generate contextually relevant code suggestions has the potential to transform how developers write software. However, it’s crucial to use Copilot responsibly and recognize its limitations. After all, AI lacks the intuition and experience that human developers bring to the table. Therefore, developers remain essential—and AI won’t be replacing us anytime soon.

💡 If you haven’t tried it yet, now is the perfect time to integrate GitHub Copilot into your workflow and boost your productivity! 🚀

The taboo of using Artificial Intelligence in the workplace: Demystifying myths and enhancing benefits

In the digital age, the integration of artificial intelligence (AI) in the workplace has emerged as one of the most transformative factors. Despite the undeniable benefits these tools offer, a lingering taboo still generates concern and resistance in many corporate environments. This phenomenon is largely driven by fears of automation, job displacement, and distrust in algorithm-based decision-making. However, a deeper analysis reveals that, when implemented responsibly, AI not only complements human talent but also enhances efficiency and innovation.

Origins and Causes of the Taboo

Skepticism toward AI in the workplace stems from several factors:

• Fear of Automation: The perception that machines will replace human roles generates anxiety and resistance among workers, particularly in repetitive or administrative jobs.

• Distrust in Automated Decision-Making: The idea of delegating critical decisions to algorithms—whose internal processes sometimes appear opaque—creates uncertainty and concerns about fairness and justice in business decisions.

• Media and Cultural Impact: The portrayal of AI in popular culture and certain media narratives reinforces myths about artificial “intelligence,” fueling fears that often exceed the reality of its application.

Key Benefits of AI Integration in the Workplace

Despite concerns, the benefits AI brings to organizations are numerous and significant:

• Increased Productivity: Automating routine tasks frees up employees to focus on strategic and creative activities, improving operational efficiency.

• Optimized Decision-Making: AI-driven systems can analyze vast amounts of data in real-time, providing valuable insights that enable more informed and accurate decisions.

• Enhanced Customer Service: Tools such as chatbots and recommendation systems personalize the user experience, optimizing interactions and increasing customer satisfaction.

• Cost Reduction and Efficient Resource Use: AI’s ability to identify inefficiencies in processes and optimize resource utilization leads to significant cost savings and better asset management.

• Fostering Innovation: AI creates new opportunities for product and service innovation, driving competitiveness and adaptability in an ever-changing market.

Integration and Adaptation into Organizational Culture

To overcome the taboo and maximize AI’s advantages, organizations must proactively manage change:

• Training and Education: Investing in training programs that familiarize employees with AI tools and their practical applications helps dispel fears and promote a culture of continuous learning.

• Communication and Transparency: Establishing clear communication channels to explain how AI systems function, what decisions they automate, and how they are monitored builds trust and reduces perceptions of opacity.

• Gradual Implementation and Pilot Testing: Gradually adopting AI through pilot projects allows organizations to assess its impact, adjust processes, and tangibly demonstrate benefits, facilitating internal acceptance.

Success Stories and Practical Examples

Various companies have already demonstrated that the responsible use of AI can positively transform the workplace:

• Financial Sector: Banks and financial institutions use AI algorithms for early fraud detection, risk analysis, and personalized services, achieving greater efficiency and security in their operations.

• Customer Service: Telecommunications and e-commerce companies have implemented chatbots that enhance user experience, reduce wait times, and enable 24/7 support without compromising quality.

• Process Optimization: In manufacturing and logistics industries, AI helps predict maintenance needs, manage inventories, and optimize distribution routes, leading to significant cost savings and reduced operational errors.

These examples show that, when carefully implemented, AI does not replace workers but instead enhances their capabilities, allowing them to focus on higher-value tasks.

Ethical Considerations and Implementation Challenges

The adoption of AI in the workplace also requires addressing critical ethical and security issues:

• Avoiding Bias and Ensuring Fairness: Designing algorithms that are fair and free from biases is essential to ensure that automated decisions do not perpetuate existing inequalities.

• Data Protection and Privacy: Responsible data management is crucial to safeguarding employee and customer privacy while complying with international regulations and standards.

• Accountability and Oversight: Establishing audit and control mechanisms to monitor AI systems ensures that they operate in alignment with organizational values and objectives.

Addressing these challenges ethically not only increases trust among internal and external stakeholders but also strengthens a company’s market reputation.

Conclusion

Although the use of artificial intelligence in the workplace has historically been surrounded by taboos and fears, its benefits are undeniable. By automating repetitive tasks, optimizing processes, and improving decision-making, AI serves as a strategic ally for enhancing productivity and innovation. To achieve successful integration, companies must invest in training, foster transparency, and establish robust ethical oversight mechanisms. Ultimately, by breaking the stigma and adopting a responsible approach, businesses can transform their workplaces, drive growth, and secure a competitive edge in an increasingly digital and dynamic market.

Iván L.

Front-end development is constantly evolving, with new technologies and approaches redefining how we build web applications each year. As we approach 2025, it is crucial to understand the trends shaping the future of the industry and prepare for the changes ahead. Below, we explore the key trends that will influence front-end development in the coming months.

1. Server Components in React

React remains one of the most popular frameworks, and with the introduction of Server Components, the rendering model will undergo a significant transformation. This feature allows more UI logic to run on the server, reducing the client-side load and improving overall performance. In e-commerce applications, for instance, products can be rendered on the server and sent pre-processed to the client, decreasing load times and enhancing user experience.

2. More Efficient Frameworks: Qwik, SolidJS, and Svelte

While React and Vue continue to dominate the ecosystem, new frameworks like Qwik, SolidJS, and Svelte are gaining popularity due to their focus on efficiency and performance optimization. These frameworks offer faster load times and a better user experience by minimizing JavaScript usage on the client side. Qwik, for example, implements an extreme “lazy loading” system, only loading the necessary code exactly when needed, preventing unnecessary downloads and improving interaction speed in feature-rich applications.

3. Artificial Intelligence in Development

AI is already transforming web development with tools like GitHub Copilot, ChatGPT, and Codeium. By 2025, these tools will become even more sophisticated, helping developers write code faster, detect errors, and optimize applications more efficiently. For example, GitHub Copilot can autocomplete entire functions based on comments or code snippets, allowing developers to reduce time spent on repetitive tasks and enhance productivity in large-scale projects.

4. CSS Evolution: Container Queries and New Features

CSS continues to evolve with the introduction of Container Queries, enabling more flexible designs without relying on media queries. This means components can adapt based on their container size rather than the full screen size, making layouts more modular and reusable. Additionally, new features like :has(), @scope, and color-mix() will empower designers and developers, allowing for more dynamic and efficient styling without extra JavaScript.

5. Micro-Frontends in More Projects

Micro-frontends architecture allows large applications to be divided into smaller, independent parts, improving scalability and maintenance. Platforms like Netflix, for example, can separate different sections of their application into autonomous modules—such as recommendations management, content library, and video player—allowing updates without affecting other parts of the application. This modular approach facilitates team collaboration and enhances development efficiency in large-scale projects.

Front-end development in 2025 will be defined by efficiency, performance optimization, and the integration of new technologies like Micro-Frontends and Artificial Intelligence. Staying updated will be key for developers to leverage these trends and create innovative web experiences. Are you ready for the future of web development?

Jules P.