This week was largely focused on improving and refining existing functionality inside Nexus. Much of that work was driven directly by feedback and our own day-to-day usage of the platform. In many ways, those are the most valuable updates, because they expose where friction still exists and where improvements have the biggest practical impact.

Active Pilots

The biggest milestone this week was the delivery of two active pilots.

Although both pilots were mentioned previously, this week marked the formal handover to the teams involved so they can start properly test-driving Nexus within their normal daily operations. Until now, both teams were already using the platform, but continuous development and ongoing releases from our side meant the environment was still changing too frequently to fully integrate into regular workflows.

As of this week, both organizations now have a stable version configured around their requested use cases, allowing them to start using Nexus as part of their actual operational routines. The coming weeks will be important, because this is where we move from development-driven testing into real-world usage. 

Both pilots revolve around combining structured and unstructured data from multiple sources. In both environments, employees spend a significant amount of time searching for information and trying to access the right context at the right moment. Nexus is aimed at reducing exactly that friction by making fragmented information directly accessible through a single interface.

Across these pilots, we connected PDF documentation, static data sources, internet-based information, and even voice data from phone conversations, making all of it searchable and queryable through Nexus. One pilot operates in the real estate domain, while the other is being developed for a governmental agency.

Dashboarding, Google marketplace and Advanced Technology!

Feedback from the past weeks also pushed us toward improving the visual and dashboarding capabilities of Nexus.

In many situations, a textual answer alone is not enough. Users often want to persist certain outputs or metrics into dashboards that can continuously monitor and visualize operational data. While graphical functionality already existed inside Nexus, it was still relatively immature. This week we introduced the next step in that evolution: text-to-dashboard functionality.

Users can now directly push answers, metrics, or query outputs into dashboards without requiring technical knowledge or support from data specialists. The goal is straightforward: allow non-technical and non-data-savvy users to create their own plug-and-play dashboards directly from natural interaction with Nexus.

On top of that, we're introducing slideshow functionality for dashboard tabs. This allows teams to configure rotating dashboards across different operational domains such as sales funnels, revenue tracking, or HR-related insights. Dashboards automatically refresh and rotate between views, making them particularly useful for management teams and operational monitoring screens.

We also made several improvements related to the Google Marketplace deployment. As mentioned previously, this remains a highly complex process that consumes a significant amount of DevOps and development capacity. The primary challenges are currently focused on the backend architecture, where multiple services and supporting software components need to be deployed through a single-click setup.

In some cases, this could easily be solved through additional licensed infrastructure or paid third-party solutions. However, we are deliberately trying to avoid creating extra licensing costs (for the end-user) on top of Nexus itself, even if that means taking a slower and more difficult development route.

Another area where we made strong progress was speech-to-text processing.

Initially, the focus was mainly on generating summaries and extracting actionable items from conversations. We now also support full transcription and injection of those conversations directly into Nexus data lakes, making spoken interactions part of the broader searchable knowledge ecosystem.

Performance improvements were also introduced, allowing us to process multiple 15-minute conversations almost instantly. It may not be the flashiest feature on the surface, but it is critical for real-world scalability because it moves us much closer toward supporting real-time processing capabilities for call-centers.

At the same time, we continued improving one of the most fundamental parts of the Nexus architecture: automatic metadata generation.

This remains one of the core building blocks behind how Nexus operates and scales. Better metadata generation directly improves how effectively data can be categorized, understood, and retrieved across larger ecosystems. In practice, stronger metadata means better searchability, better answers, and ultimately a more useful platform for customers.

It is also one of the areas where we believe Nexus differentiates itself most strongly from many traditional RAG-based architectures. A large number of existing solutions struggle with scalability because they depend on continuously rebuilding and updating massive retrieval layers, often daily or even hourly, regardless of whether the data is actively being used.

Our approach is fundamentally different. By keeping data largely idle until it is actually needed, while relying on metadata and contextual orchestration to locate and activate the right information dynamically, we can scale much more efficiently while reducing unnecessary processing overhead.

Business Development 

On the business development side, we also started a very early-stage medical PoC this week.

The opportunity emerged around potentially reducing external data science support costs by as much as €150K annually. It is still early, but we are currently exploring the operational needs, technical possibilities, and potential value creation within that environment.

Alongside that, several upcoming meetings are directly connected to the recently completed pilots. One thing we continue to learn is that going deep into a specific domain creates much more than just a technical implementation. It gives us a much stronger understanding of the workflows, pain points, operational bottlenecks, and user behavior within that industry.

That deeper understanding makes future conversations significantly easier, because we are discussing real operational challenges that organizations actively recognize themselves.