Why the rebuild? My previous attempt was a full Next.js application with a database, authentication, payments, background jobs, and monitoring. It could do everything except stay online and stay maintained. A personal website doesn’t need any of that: it needs to be readable, fast, and trivially easy to change. So I moved to a static Jekyll site hosted directly on GitHub Pages — no server, no database, no build pipeline to babysit. GitHub builds the site automatically on every push.

How maintenance works now — and this is the part I care about:

• Publishing a post means creating one markdown file: _posts/YYYY-MM-DD-title.md with a small front-matter block (title, date, description, tags) and the content below it. Commit, push, and the site rebuilds in about a minute. It can even be done from the GitHub web editor on my phone.
• Editing projects, experience, or skills means changing one data file: _data/site.yml. All the sections of the homepage are generated from it.
• Design changes live in a single stylesheet, assets/css/style.css. There is no JavaScript, no framework, and nothing to update for security.

The old articles — on deep reinforcement learning for vertiport operations, the European U-space framework, and building agents with LangChain and local LLMs — were migrated from the previous site, and they’re all listed in the blog archive.

Here’s to shipping the boring, reliable version.

At its core, a LangChain agent operates through a reasoning loop: the LLM receives a task, determines which tools to use, executes them, observes the results, and iterates until the task is complete. The ReAct (Reasoning + Acting) pattern is the most common approach, where the agent alternates between thinking about what to do next and actually doing it. For example, an agent tasked with researching a topic might search the web, read documents, summarize findings, and compile a report — all without human intervention. LangChain’s modular architecture lets you plug in different LLM backends, including locally hosted models through frameworks like Ollama or llama.cpp, giving you full control over inference parameters, context windows, and model selection.

Building effective agents requires careful attention to several design decisions. First, tool design is critical: each tool should have a clear, descriptive name and docstring that the LLM can understand, as the model uses these descriptions to decide which tool to invoke. Second, memory management determines how much context the agent retains across interactions — LangChain offers conversation buffer memory, summary memory, and vector store-backed memory for long-term recall. Third, error handling and retry logic are essential, as LLMs can produce malformed tool calls or hallucinate non-existent capabilities. Implementing guardrails — such as output parsers that validate the agent’s responses and human-in-the-loop approval for sensitive actions — transforms a fragile prototype into a production-ready system.

The practical advantages of running LLMs locally for agent development are substantial. Data never leaves your infrastructure, making this approach suitable for handling sensitive documents, proprietary code, or personal information. Inference costs are fixed to hardware rather than scaling with token usage, enabling extensive experimentation and testing without budget concerns. Furthermore, local deployment eliminates API latency and availability concerns, allowing agents to run continuously as background services. With the rapid pace of open-source model development — where new models regularly match or exceed the capabilities of previous-generation proprietary systems — the case for local LLM agents has never been stronger. Whether you’re building a personal research assistant, an automated code reviewer, or a multi-agent simulation system, the combination of LangChain and local LLMs provides a powerful, privacy-preserving foundation.

The U-space framework is structured around four progressive service levels, each building upon the previous one. U1 (Foundation Services) provides e-identification and geo-awareness capabilities, ensuring that all drones can be identified and that operators are aware of flight restrictions. U2 (Initial Services) adds flight planning, strategic deconfliction, and weather information. U3 (Advanced Services) introduces tactical deconfliction, collision avoidance, and capacity management — the services most critical for high-density urban operations. Finally, U4 (Full Services) envisions a fully integrated system with autonomous demand-capacity balancing and collaborative decision-making. The European Union Aviation Safety Agency (EASA) has been working with national aviation authorities to define the regulatory framework that will govern each of these service levels.

The technical architecture of U-space relies on a service provider model, where certified U-space Service Providers (USSPs) offer competing services to drone operators while ensuring interoperability through standardized interfaces. This market-driven approach is designed to foster innovation while maintaining safety. Key enabling technologies include real-time telemetry sharing via UTM (UAS Traffic Management) protocols, digital flight permissions, and dynamic geofencing that can adapt to changing conditions such as emergency events or temporary flight restrictions. The Common Information Service (CIS) acts as the authoritative source of airspace data, ensuring that all USSPs operate from a consistent picture of the operational environment.

The implications of U-space extend far beyond regulatory compliance. For the aerospace industry, it opens new markets for service provision, sensor integration, and autonomous flight systems. For cities, it offers the promise of efficient last-mile delivery, infrastructure inspection, and emergency response capabilities. However, significant challenges remain: ensuring cybersecurity of the communication infrastructure, addressing public acceptance of low-altitude drone operations, and developing the computational systems capable of managing thousands of concurrent flights in real time. As Europe moves toward operational U-space deployment, the lessons learned will shape the global trajectory of urban air mobility for decades to come.

Deep Reinforcement Learning (DRL) offers a compelling framework for addressing this challenge. By modeling vertiport operations as a Markov Decision Process (MDP), we can train intelligent agents to make real-time decisions about aircraft sequencing, gate assignment, and departure scheduling. In our research, we employed Proximal Policy Optimization (PPO), a policy gradient method that has demonstrated remarkable stability and sample efficiency across a range of continuous control tasks. The agent observes the current state of the vertiport — including queued aircraft, weather conditions, pad availability, and fuel constraints — and learns a policy that maximizes throughput while maintaining safety margins. Unlike rule-based systems, the DRL agent adapts to novel situations and can handle the stochastic nature of arrival patterns.

Our multi-agent extension places independent PPO agents at each vertiport within a network, enabling decentralized coordination. Using a shared reward signal that penalizes delays and safety violations, the agents learn to cooperate without explicit communication protocols. Simulation results across a modeled urban corridor with six vertiports showed a 34% improvement in throughput compared to first-come-first-served scheduling, with a 61% reduction in safety margin violations. The agents discovered emergent strategies such as holding patterns and dynamic pad reallocation that were not explicitly programmed, demonstrating the creative problem-solving capacity of DRL in safety-critical systems.

Looking ahead, integrating DRL-based scheduling into the broader U-space framework will be essential for scaling urban air mobility. U-space, Europe’s vision for drone traffic management, envisions a highly automated system where service providers manage airspace dynamically. Our research suggests that DRL agents could serve as the decision engine within U-space service providers, handling the real-time optimization that human operators cannot perform at the required speed. Future work will focus on transfer learning across vertiport topologies, robustness to adversarial scenarios, and the critical step of bridging the sim-to-real gap through hardware-in-the-loop testing.