Search on website

Priyanka Futane, Lecturer in AI Agent Development at Business Technology Academy and Senior Software Engineer at Stryker, discusses AI agents, her career in tech, and why the future belongs to developers who can build intelligent systems, not just use AI tools.

What is your background in Full-Stack Web Development?

I have over six years of industry experience in software engineering, with a strong foundation in full-stack development and building scalable enterprise applications.

My experience covers the complete software development lifecycle — from understanding business requirements and designing solution architecture, through application development, backend services, API integration, data management, testing, deployment and continuous improvement. Over the years, my focus has evolved from simply building web applications to thinking more broadly about distributed systems, cloud-based architectures, API-driven applications, automation and intelligent software systems.

I’ve worked across modern frontend and backend ecosystems, building services and APIs, integrating data sources and enterprise platforms, and working with CI/CD and cloud environments.

A key area of my experience is system integration — connecting applications with databases, internal services, third-party APIs, cloud platforms and business systems. That foundation translates directly into AI agent development. Production agents require more than an LLM: they need context, tools, APIs, data, permissions, business logic and controlled actions.

My full-stack background allows me to engineer the systems around the AI, not just the model interaction. That’s the perspective I’d bring to students: AI agent development is software engineering applied to intelligent, tool-enabled systems — not simply prompt engineering.

How have you been using AI Agents in your work?

My work with AI has evolved from using LLMs as development assistants to designing agentic workflows where AI can reason about a task, use tools, interact with external systems and execute multiple steps toward a goal.

When I approach an agent-based solution, I don’t begin by asking, “How can I use an LLM here?” I start with the problem: What is the objective? What information does the agent need? What tools should it have access to? What decisions can it make autonomously? What actions should require approval? And how do we measure whether it actually succeeded?

I’ve worked with this architecture at the application level — connecting AI capabilities with APIs, business data and automation workflows, and designing the surrounding logic required for an agent to perform useful tasks rather than simply return a conversational response.

A key area I focus on is tool use. For example, instead of giving an agent access to an entire system, I define specific capabilities as tools — perhaps retrieving information, querying a database, calling an API, analysing a dataset or triggering an approved business operation. The agent can then determine which tool is appropriate based on the task and the available context.

I’m also very interested in the emerging standards around agentic systems. The Model Context Protocol (MCP) is becoming an important standard for connecting AI applications with tools, resources and external context, while Agent2Agent (A2A) addresses communication and collaboration between independent agents.

That distinction is important when teaching students because it moves the conversation from “How do I build a chatbot?” to “How do I build an AI system that can interact with the real world in a controlled, observable and reliable way?”

How have AI Agents changed the role of the Web Developer?

I think AI agents are fundamentally changing the abstraction level at which developers work.

Traditionally, we designed applications around fairly deterministic workflows: User → Interface → Backend → Database → Response.

With agentic systems, we can introduce another layer: User → Agent → Reasoning → Context → Tools/APIs → Actions → Result.

The developer therefore isn’t only responsible for writing application logic anymore. We increasingly need to design the environment in which an AI system operates. That includes defining the tools it can access, the context it receives, the permissions it has, the boundaries around its actions, the way errors are handled and the mechanisms we use to evaluate its behaviour.

This is particularly important because AI systems are probabilistic. Traditional software can often be tested with a simple expectation: given this input, the system should return this output.

With agents, evaluation becomes more nuanced. We need to ask: Did the agent understand the objective? Did it choose the correct tool? Did it use the correct parameters? Did it retrieve the right information? Did it follow the required policy? Did it complete the task?

So I see the role evolving into something closer to an AI-enabled software engineer or agentic systems engineer — someone who understands both conventional software architecture and how intelligent systems can operate within it.

What made you interested in a career in Software Development?

What attracted me to software development originally was problem solving.

I enjoy taking something that is ambiguous or complex and breaking it down into smaller, logical components that can eventually become a working solution. But what has kept me in software engineering for more than six years is the fact that the field constantly evolves.

I’ve experienced the transition from traditional application development towards APIs, distributed architectures, cloud platforms, automation and now AI-enabled and agentic applications. Every stage requires you to rethink how you build software.

I particularly enjoy that combination of technical depth and creativity. There may be several technically valid solutions to a problem, but the real challenge is deciding which architecture is appropriate for the business, the users, the data and the scale of the system.

AI makes that even more interesting because we’re now building systems where software can interpret intent, reason over information and decide which tools or actions are appropriate. For me, that’s a very natural evolution of software engineering.

Why do Software Engineers need to learn about AI?

Because AI is becoming part of the application architecture itself. I don’t think every software engineer needs to become a machine-learning researcher. But I do believe modern software engineers need to understand how AI systems behave and how they should be engineered into real applications. We’re moving beyond simply adding a chat interface to an application.

AI can now be integrated into applications as a reasoning and decision-making layer — retrieving information, calling tools, interacting with APIs, generating structured outputs and orchestrating workflows. That means developers need to understand things like context management, retrieval, tool calling, agent orchestration, evaluation, observability, security and human oversight. And there is an important engineering principle here: just because an AI system can perform an action doesn’t mean it should be allowed to perform that action autonomously.

We need to design appropriate permissions, validation and human-in-the-loop controls. That’s why I see AI knowledge as an extension of software engineering rather than a completely separate discipline.

The strongest engineers will be the ones who understand both sides: how to build reliable software, and how to integrate intelligent, probabilistic components into that software responsibly.

What skills do you need to succeed in AI Agent Development?

I would divide this into several levels.

First, you need strong software engineering fundamentals.

You need to understand programming, APIs, databases, authentication, system architecture, testing, version control and deployment. Without those foundations, it is difficult to build production-grade agents.

Second, you need to understand how modern AI models work and what their limitations are.

That includes concepts such as context windows, embeddings, retrieval, structured generation, tool calling and model selection.

Third, you need to understand agent architecture.

That’s where we start thinking about tool-using agents, planning and orchestration, memory, retrieval-augmented generation (RAG) systems, workflow-based agents, multi-agent architectures and protocols such as MCP and A2A.

MCP, for example, provides a standardised way for AI applications to interact with external tools and data, while A2A is designed around communication between agents.

But I think the fourth skill is even more important: AI systems engineering.

Building a prototype is relatively easy. Building something reliable is much harder. You need to think about many things, including testing, permissions, AI hallucinations and human approvals.

Fifth, you need strong problem-decomposition skills.

A good agent developer doesn’t simply give an LLM access to everything. They define what the goal is, what is required and how to evaluate success. That’s the engineering mindset I would want students to develop.

Why should someone consider a career in Web Development and AI Agent Development?

I think we’re entering a period where software development is becoming much more intelligent and much more autonomous. Web development gives you the foundation for building real applications and services. AI agent development adds the ability for those applications to understand intent, reason over information, use tools and participate in complex workflows. And I think that’s why this is such a strong career combination.

A developer who understands both software engineering and AI can build much more than a chatbot. They can build intelligent enterprise assistants, research agents, data-analysis systems, developer tools, workflow automation, customer-service systems and multi-agent applications.

For students, I think the opportunity is particularly exciting because they don’t have to choose between software engineering and AI. They can build the fundamentals of software engineering and then learn how to add intelligence and autonomy on top of those foundations. And that’s exactly how I would approach teaching this course. I wouldn’t want students to finish the course knowing only how to write prompts or connect an API to an LLM. I want them to understand how to design, build, integrate, evaluate and deploy agentic systems.

My goal would be to take students from understanding the fundamentals of LLM-based applications, through building tool-using agents, and then towards more sophisticated agentic architectures involving retrieval, orchestration, external systems and potentially multi-agent collaboration.

Ultimately, I want them to leave the course thinking like software engineers who can build intelligent systems, rather than simply good users of AI tools. That, in my opinion, is where the real value of AI agent development lies.

Want to learn the Fundamentals of AI Agent Development? Check out the Course details in the Courses Page above