The open kitchen: why your tools should be visible

There’s a concept in restaurant design called the open kitchen, where instead of hiding the kitchen behind a wall you let diners see the cooks work, and the food doesn’t taste different but the experience is fundamentally changed because the customer understands what’s possible. They see the wood-fired oven and think “I wonder if they could do my pizza that way,” they watch the chef work the grill and ask for something off-menu, and the visibility of capabilities creates demand that a closed kitchen never would. Software does the opposite, it hides capabilities behind menus and buried settings and documentation that nobody reads.

The hidden capability problem

Every complex software system has capabilities that most users never discover, not because the capabilities aren’t useful but because the users don’t know they exist, and this is true for our AI agent system too with 46 registered tools where an agent working with a user can search databases and analyze data and generate reports and monitor operations and extract entities from text and search the knowledge graph and dozens of other things, but if the user doesn’t know to ask for these capabilities they never get used. The traditional solution is documentation, you write a manual and create a help center and build a guided tour, but documentation assumes the user has a problem and goes looking for a solution, whereas the most valuable discoveries happen the other way around where the user sees a capability and realizes it could solve a problem they hadn’t thought to address.

Why AI agents make this worse

With traditional software at least you have a menu to browse and you can poke around the interface to discover features, but with AI agents there’s no menu, there’s a conversation where the user asks for something and the agent responds, and if the user doesn’t ask for something the agent can do they’ll never know it can do it, which creates a frustrating dynamic where the agent has capabilities the user would love to use but neither the agent nor the user surfaces them because the agent doesn’t proactively advertise its tools and the user doesn’t know to ask about them, and the conversation interface that makes AI agents so accessible also makes capability discovery almost impossible.

The open kitchen approach

Our approach is to make the agent aware of its own capabilities in a way that lets it surface relevant ones proactively, and we built a tool discovery module that uses semantic search to match available tools to the current conversation context. When a user is discussing a topic the tool discovery module identifies which of the agent’s capabilities are relevant to that discussion even if the user hasn’t asked for them, and the agent can then mention those capabilities naturally, “I can pull the data on that if you’d like” or “We have a tool that tracks exactly this kind of pattern.” This is the open kitchen because the user sees what’s possible because the system makes capabilities visible in context, not buried in a manual.

Discovery changes usage patterns

Something interesting happened when we started surfacing capabilities proactively, and users started asking for things they’d never asked for before, not because the capabilities were new but because the users finally knew they existed, like an operator who had been manually tracking a metric and discovered the agent could monitor it continuously and alert on changes (they didn’t go looking for that feature, the agent surfaced it during a conversation about the metric) or a user who had been copying data between systems and discovered the agent could do the integration automatically (the capability had existed for weeks, but the user didn’t know to ask until the agent mentioned it in context). Each discovery expanded the user’s mental model of what the system could do, which led to more sophisticated requests, which surfaced more capabilities, a virtuous cycle that only works when capabilities are visible.

The broader principle

The open kitchen isn’t just about tool visibility, it’s about a design philosophy where the best systems don’t just do what they’re told but help users understand what’s possible, and this applies to knowledge too because an agent with a rich knowledge base should surface relevant knowledge proactively and not wait for the user to ask the perfect question, because “based on what you’re working on, you might want to know that we documented a similar situation last month” is more valuable than waiting for the user to search for it, just like “you mentioned a concern about this last time we discussed it” is more valuable than the agent treating each conversation as if the previous one never happened. Visibility is how systems become partners rather than tools, because a tool does what you ask while a partner shows you what’s possible, and the open kitchen is how you build the second kind.