Full-Stack AI Engineering in TypeScript: Notes from a London Bootcamp

In early May 2026, we attended the Full-Stack AI Engineering in TypeScript Bootcamp led by Nir Kaufman during the iJS conference in London. The workshop focused heavily on practical examples built around the LangChain ecosystem and modern AI agent orchestration patterns in TypeScript.

What stood out most was not just “how to call an LLM”, but how quickly the conversation moved toward engineering concerns that become critical in real-world AI systems.

Experimenting with AI prompts brings some results and the conversation can be successful, however the AI workflows can be far beyond predictable and maintainable. The workshop focused on creation of safe and clean production-grade AI systems, especially covering the topics like collaboration of multiple agents, tools that help agents interact with external systems, use of state, enforcing structured outputs from AI response or advanced prompt engineering. Let’s look at these topics together in this article.

Multi-Agent Architectures

Unlike in Matrix, in the AI world the agents are actually the good guys. It is not a simple chatbot that only generates text responses anymore, an agent can actively interact with its environment. One of the most interesting parts of the workshop was the discussion around AI agent architectures. At a high level, an AI agent is an AI-powered system that can reason about a task, decide what actions to take, use external tools and iteratively work toward a goal.

Instead of one “universal” agent handling everything, the system can delegate responsibilities between specialized agents. Multi-agent patterns are particularly valuable when a single agent has too many tools and makes poor decisions about which to use, when tasks require specialized knowledge with extensive context (long prompts and domain-specific tools), or when you need to enforce sequential constraints that unlock capabilities only after certain conditions are met [1].

In the workshops, we were introduced to 3 architectures in which AI agents can cooperate:

Subagents

In the subagents architecture, a central main agent (often referred to as a supervisor) coordinates subagents by calling them. The main agent decides which subagent to invoke, what input to provide, and how to combine results [2].

For example one agent searches documentation, another writes code, another validates output, another summarizes findings. The supervisor decides which agent should act, in what order and when the workflow is complete. Subagents return results to the main agent, not the user.

This pattern feels very similar to modern distributed systems architecture — except the orchestration layer now includes reasoning capabilities.

Handoffs Pattern

Another interesting approach was the handoffs architecture [3]. Instead of a central controller making every decision, one agent can transfer the task to another specialized agent once certain conditions are met. Behavior changes dynamically based on state.

In the workshop we used an example where one agent recognized leftover ingredients from the photo of a user’s fridge. Another agent took over and asked about the allergies on the specific foods. When this was clear and the user had no allergies, the ingredients and no allergies state was passed to the chef agent - the agent that searched the web for yummy food recipes with the given ingredients.

Each agent used different tools and different ways to coordinate their task. It always used the information from the previous agent in the form of a state and moved on. This created a workflow that resembled collaboration between real engineering teams. The important takeaway was that AI systems are increasingly designed as cooperative networks of agents, not isolated prompts.

Skills Pattern

A very popular pattern is the skills architecture because it is rather easy to implement. Specialized capabilities are packaged as invocable “skills” that augment an agent’s behavior. Skills are primarily prompt-driven specializations that an agent can invoke on-demand [4].

Use the skills pattern when you want a single agent with many possible specializations. For example, consider an AI cooking assistant designed to help users plan meals and cook recipes. Instead of creating separate agents for nutrition, recipe generation, grocery planning, and cooking guidance, the system exposes each capability as an independent skill:

• Recipe Generation Skill — Creates recipes based on ingredients, cuisine, or dietary preferences.
• Nutrition Skill — Calculates calories, protein, carbohydrates, and allergen information.
• Meal Planning Skill — Builds weekly meal schedules optimized for budget or health goals.
• Ingredient Substitution Skill — Recommends alternatives when ingredients are unavailable.
• Cooking Guidance Skill — Provides step-by-step instructions and adjusts timing while the user cooks.
• Shopping List Skill — Converts selected recipes into organized grocery lists.

At runtime, the cooking assistant selects the appropriate skills dynamically. A request such as, “Create a high-protein vegetarian dinner using chickpeas and spinach,” could trigger the Recipe Generation Skill first, followed by the Nutrition Skill to verify protein content, and finally the Shopping List Skill to prepare missing ingredients.

Tools Are What Make Agents Truly Useful

An LLM without tools is giving only the responses that it was trained for. Tools fundamentally extend what an AI agent can do - API integrations, database queries, web search, filesystem access and others can enhance the capability of the agent greatly. The interesting part was not only adding tools, but controlling when the model may use them - via a dedicated agent. This turns the AI system from a passive responder into an active orchestrator.

Structured Outputs with Zod

One of the most practical engineering topics was the use of Zod for validating AI outputs. LLMs are probabilistic systems. Even when prompted carefully, they can generate incomplete structures, extra spaces or unexpected values.

Using schemas introduces predictability. With Zod in typescript we are able to guarantee JSON structure and improve the reliability of the output that is further used in the workflow. This can be directly used to create interesting UI components with the data coming from the AI response or simply to validate the values and debug easier.

For TypeScript teams, this is especially powerful because the AI layer can integrate directly into strongly typed application architecture. We can work with AI responses as with any other outputs from API calls that we used before.

State Management Becomes Critical in AI Systems

As workflows become more advanced, the application needs to manage conversation history, intermediate reasoning, tool results, workflow progress, user context and memory across steps.

Without proper state management, AI systems quickly become difficult to debug and unpredictable. It forget what it asked for and can reply randomly. Collecting the data in the state and using them in the next iteration of the workflow in the prompt can support the reliability of the whole system.

In our testing AI app, we needed to remember what ingredients were on the picture of the fridge, if the user is allergic and other preferences. Each agent then used the state that was previously collected by another agent, without forgetting the essentials.

Conclusion

The Full-Stack AI Engineering in TypeScript Bootcamp was less about “AI magic” and more about practical engineering patterns for building reliable AI systems.

Perhaps the most valuable takeaway from the workshop was this: Building AI applications is rapidly becoming a software engineering discipline — not just prompt experimentation. Many established engineering principles are directly applicable to AI systems.

From a business perspective, workshops like this are important because they help us understand not only the current AI tooling landscape, but also where modern application architecture is heading.

Many companies are still experimenting with AI through isolated chatbot prototypes. This provides results but the control over them is questionable. Understanding how to engineer these systems safely and maintainably is becoming increasingly important. The workshop provided valuable insight into how modern TypeScript ecosystems are evolving to support this next generation of AI-powered applications.

References

[1] Multi agents, Langchain documentation, https://docs.langchain.com/oss/python/langchain/multi-agent

[2] Subagents, Lanchain documentation, https://docs.langchain.com/oss/python/langchain/multi-agent/subagents

[3] Handoffs, Langchain documentation, https://docs.langchain.com/oss/python/langchain/multi-agent/handoffs

[4] Skills, Langchain documentation, https://docs.langchain.com/oss/python/langchain/multi-agent/skills