Meter Command: software should be soft

Software originally held a promise: freely leverage hardware towards user needs. But as use cases, product segments, and verticals solidified, software rigidified. Our latest product, Meter Command is, in part, an ode to reversing this trend. We believe software should be soft again.

Today's software is a lot like buttons on hardware – in a car, on appliances, or on a remote. You can modify what buttons do to some extent, but you can not really make the interface yours. The original promise of software was to empower users to program existing apps or create what they need on the fly and in a personalized way. However, applications today feel more rigid than ever - moving away from the principles they started with. This rigidity is even more so pronounced in infrastructure.

Infrastructure, and in particular networking, has been command-line interface (CLI) driven for decades. The last major shift was moving from CLI to cloud-based dashboards. This shift to dashboard environments led to ease of deployment, remote management, and better usability. However, with the shift away from CLIs, there have not been ways for users to have fine-grained control over infrastructure improvements. Even more problematically, IT and Networking teams are being asked to do more with less resources.

We believe combining the best aspects of both dashboards and CLIs into one product will alleviate the mounting pressure on IT teams. At Meter, we have spent the last decade building an end-to-end solution with our own hardware, cloud-based software, and fully-managed operating system. We make it incredibly easy for any business, organization, or school – of any size – to get reliable access to the internet. Our vertical integration allows us to create novel solutions that leverage this full-stack control, bringing us closer to the original vision of truly soft, adaptable software. The architectural decisions we have made over the past 10 years have enabled us to build a unified stack across ISP management, routing, switching, wireless, security, DNS security, VPN, and SD-WAN.

With Command, we have taken the important building blocks and redefined the interface. Command is a generative UI that enables IT and Networking teams to use natural language to operate and generate dashboards for configuration and rapid resolution. Command does not just answer questions – it generates software and entire dashboards on the fly. We leverage all of our hardware, software, architecture, and models - putting them all together through Command, enabling a step-function change in our customers’ abilities to manage their networks.

CLI → Dashboards → Command

CLI offers precise control but requires specialized knowledge. The shift to cloud-based dashboards brought visual interfaces and remote management capabilities, making it easier for a broader range of users to have visibility into their infrastructure and interact with it.

Unlike CLIs, Command allows users to speak directly to their networks and hardware in plain English. And unlike traditional dashboards, Command dynamically generates custom software interfaces, comprehensive dashboards, and concise answers exactly as you want it, providing a truly adaptive and personalized experience. Whether you are a seasoned network professional or a non-technical user, Command adapts to your level of expertise, making complex tasks simpler and routine operations more efficient.

Core design principles

1. Accuracy: In the world of network infrastructure, precision is paramount. Command is designed to provide accurate, reliable information and execute changes with exacting precision. Our models are built in-house to understand the nuances of both networking concepts and how we build backend and frontend software, ensuring that user intentions are correctly interpreted and acted upon. The data Command uses to create dashboards and answer questions are stitched together in real-time directly from our production backend, while maintaining customer data privacy. Given the specialization of our models, error is reduced by more than 2.5x compared to the largest state-of-the-art foundation models.
2. Speed: Information, exactly as you want it, should be available at the snap of a finger. Command is built for speed, both capable of delivering real-time responses to queries and executing changes swiftly. Our parallel execution architecture allows for simultaneous execution of multiple operations, significantly reducing wait times. Compared to state-of-the-art foundation models, latency is reduced by at least a factor of 2-3x (and, in certain scenarios, up to 10x) - almost always finishing its job in sub-second latency.
3. Usability: Managing your network should not be a chore. Command's user interface is designed to be intuitive, visually appealing, and enjoyable to use. From the natural language input to the customizable dashboards, every aspect of Command is crafted to provide a delightful user experience.

These principles do not just guide the features we build - they are woven into Command's architecture and functionality at every level, from how and why we train models, to frontend design systems.

Multiplayer and collaboration

Software is much better when it is collaborative. Command is designed with this in mind, offering robust features for team-based network management:

• Canvas view: A flexible, zoomable interface that allows you to arrange and group network elements visually. This spatial organization helps in understanding complex network topologies at a glance.
• Dashboard view: Create custom dashboards that display key network metrics and status information. These can be tailored for different roles within your organization, from IT specialists to executive overviews.
• Multiple notebooks: Create separate workspaces for different projects, teams, network segments, or question threads. This allows for organized, focused work without clutter.
• Multiplayer interface: Work together in real-time, seeing each other's actions and changes as they happen. This is particularly useful for troubleshooting sessions or collaborative network design.
• Sharing: Easily share views, dashboards, or specific network insights with team members or stakeholders, ensuring everyone has the information they need.
• Alerts: Set up customizable alerts to keep your team informed of important network events or changes, ensuring quick responses to potential issues.

These collaboration features transform network management from a solitary task into a team effort, enhancing communication, coordination, and overall efficiency.

Ease of use

Even the most powerful tools are only valuable if they are easy to use. That is why we have designed Command around customer workflows.

• Natural language querying: Ask questions about your network in plain English. For example, "Show me all devices that connected in the last 24 hours" or "What is the current bandwidth usage on the guest network?"
• Real-time updates: Components and dashboards update in real-time, giving you an always-current view of your network's status.
• Component persistence: Your custom views and dashboards are saved automatically, persisting across sessions and devices. This means you can pick up right where you left off, whether you are on your work computer or checking in from your smartphone.
• Customizable filters: Easily filter and sort network data to focus on what is most important to you. Whether you are looking at device types, usage patterns, or security events, you can quickly drill down to the information you need.
• Actionable components: Interactive elements like buttons, drawers, and tabs allow you to take immediate action based on the information you are viewing. For example, you might see an unusual traffic spike and be able to investigate or apply a filter with a single click.
• Recommended prompts: Based on your network configuration and common use cases, Command suggests relevant queries to help you get started or discover new insights.
• Automatic software generation: Command does not just answer questions - it creates custom software interfaces and full dashboards based on your queries, allowing you to interact with your network in ways previously unavailable.
• Mobile-friendly platform: If you are away from your computer, Command is just as easy to interact with on your phone.

These features come together to create an interface that is not just powerful, but also intuitive and adaptable to your specific needs and workflow.

Intelligence architecture

At the heart of Command is a carefully-crafted intelligence architecture which uniquely enables Command’s functionality. 

The main thread of our system employs a multi-stage approach to deliver customized software to users in real-time:

1. Planning mechanism: When a user submits a query, our planning mechanism analyzes the question to understand the intent relative to Command and conversational context. The planning mechanism breaks down complex requests and streams out a series of distinct high-level steps. Each planned step suggests a scoped-down contextualized question, which parts of our internal API (which spans tens-of-thousands of lines in whole) might be useful in executing the request, and what broad UI elements should be considered in that step.
2. Parallel execution: Once the plan is established, our system executes multiple, complex operations simultaneously. The execution step decides which information is retrieved from our backend, how that data should be displayed, and what should be fed into the summary step. Parallel and accurate processing is key to Command's speed and accuracy, allowing it to handle complex user queries and actions quickly. The internal logic in the execution step is designed to maximize both programmatic accuracy, and precise execution of diverse user intent. The execution step has many degrees of freedom:
   1. Database queries: Each execution step decides which database queries to write from scratch, which variables to pass into the database queries, and which Command user filters should be used in executing a database query.
   2. Database result accession: The results of the database query are nested JSON structures. Command writes logic in a new internally-designed programming language to access the data in the database response object in the exact manner it wishes. 
   3. UI display logic: Using the database result accessors, the execution step also decides how the results should be curated and displayed in the UI. It has the ability to apply database operations over many devices in a network, sort, or calculate summary statistics on the results. It may decide to filter the results by value, regex expressions, number of occurrences, or otherwise. It writes the axis labels, automatically fills-out form context, writes table headers, UI titles, and whether it should join results (how the nuances of how to join results, e.g. on which keys and whether it should be an inner or outer join) from multiple separate database queries into a single UI element in.
3. Summary: After gathering and processing the relevant data, Command synthesizes the information into a clearly-written summary. The summary ensures that the user receives only the most relevant insights from their raw data. If the user requested changes to their network, in addition to pre-filling a form to submit the action, the summary will warn the user by succinctly understanding the implications of their action before they take it.

To achieve high levels of accuracy and relevance, we are investing heavily in training models in-house:

• Synthetic data generation: We create tens of thousands of simulated user questions, conditioned on real-world use cases created by our internal teams. These data are used to simulate user behavior–regardless if the user is a networking veteran or a non-technical user. These questions are then curated and fed into later stages of Command’s synthetic data pipeline, simulating the planning and execution steps described above. While we bootstrap the synthetic data pipeline with real-world use cases, we employ self-distillation techniques to improve the synthetic data over time.
• Meticulous data curation: Since a single user query often results in multiple broken-down requests, the main synthetic data pipeline produces over a hundred-thousand synthetic individual steps, corresponding to outputs of the execution process described above. Each execution step example is run through a meticulous data filtering pipeline, which checks whether the output adheres to the syntax of our design system, languages, backend database schema, UI elements, and design system.
• Semantic data curation: We carefully curate the real-world networking training data, ensuring that our models are trained on relevant, high-quality information. This improves Command's understanding of real-world networking concepts and terminology.
• Continuous model updates: Our models are continuously updated based on user feedback and changes in our backend API. This ensures that Command stays current with the latest networking trends, Meter’s constantly-evolving backend architecture, and new features.
• Benchmarking: We rigorously benchmark our models for both accuracy and speed, constantly refining them to provide the best possible performance. Internal benchmarks are used to gate the deployment of the automatic model re-training and deployment described.

In addition to the main intelligence thread described above, there are several other components to our intelligence architecture:

• Out-of-domain refusal: Unlike other models, command is not rewarded for answering every question. Questions which are not in-domain of Command’s functionality, whether they are off-topic or related to networking but something Command does not currently do (e.g. filing support tickets), are flagged by a denial mechanism which can halt the main intelligence thread and trigger a refusal-based summary. In addition, it will reroute you to questions which it decides are in-domain of Command’s functionality and most similar.
• Recommended follow-ups: Based on the user question, Command will recommend a couple of follow-up questions to further the conversation or dive deeper into the issue in the conversation.
• Alerting: On each component, Command provides the option to set up an alert based on the UI and conversation context. It recommends which value should be monitored, what a meaningful threshold for alerting should be, and what time cadence the alert should be automatically reported on if desired. Alert suggestions, values, comparison operators, thresholds, and time cadences are recommended by Command, however all of these fields are customizable by the user.
• On-the-fly fixing: If, on the off-chance, there is an error on a certain step of the main intelligence thread, we have a real-time fixing mechanism which recognizes what the error was, why it happened, and how to fix it. The fix is applied immediately and concurrently, allowing the main thread to continue execution.

This intelligence architecture allows Command to provide fast, accurate responses while maintaining a natural, conversational interface. It is the engine that powers Command's ability to understand complex networking concepts and translate them into actionable insights and operations. We will be releasing more in-depth benchmarks and evaluations in the coming weeks.

Speed matters

Imagine if you could manage your entire network infrastructure with the speed and ease of searching on the web.  That is the level of responsiveness we have achieved with Command.

In the world of network management, speed is not just a luxury—it is a necessity. Slow responses can mean missed opportunities, delayed problem resolution, and frustrated users. That is why we have made speed a cornerstone of our design, and partnered with AI acceleration pioneer Cerebras to host our custom models and further reduce the latency of Command.

Our focus on speed manifests in several ways:

• Real-time data processing: Command processes network data in real-time, ensuring that the information you see is always up-to-date. This means you can make decisions based on the current state of your network, not on outdated snapshots.
• Rapid query execution: As a consequence of our parallel execution architecture, even complex queries are processed and answered in milliseconds, rivaling the speed of a Google search. This allows you to iterate and explore your network data in real-time without any perceptible delay.
• Output token space compression: The number of output tokens is a critical variable in determining model latency. Each step of our intelligence architecture is designed to ensure models output the fewest number of tokens needed. Furthermore, the output vocabulary is compressed, and programmatically expanded after intelligence output.
• Model quantization: Serving models in reduced floating point precision is paramount to achieving minimal latency. We managed to achieve quantized model serving without compromising accuracy.
• Instant software generation: Command does not just retrieve data quickly—it generates custom software interfaces and dashboards at the same breakneck speed. From query to fully functional interface in seconds, Command keeps pace with your thoughts and needs.
• Instant UI updates: When you make changes or run queries, the Command interface updates instantly. This responsive design keeps you in the flow, allowing for seamless exploration and management of your network.
• Proactive suggestions: Command does not just wait for your queries—it proactively suggests relevant prompts and insights based on your network's current state. This can help you identify and address potential issues before they become problems.
• Efficient data retrieval: Our backend is optimized for fast data retrieval, using advanced caching and indexing techniques to minimize query times, everything from UI to model responses to custom vector database logic conditioning auxiliary steps of our intelligence architecture.

By prioritizing speed in every aspect of Command, we ensure that you can manage your network efficiently and effectively, keeping pace with the demands of your business, organization, and network.

Built for privacy and security

At Meter, we understand that network data is not just sensitive - it is critical to your business operations. That is why we have built Command with privacy and security as fundamental principles, not afterthoughts.

Here is how we ensure the privacy and security of your data:

• Secure infrastructure: All processing for Command occurs within Meter's secure infrastructure. Your network data never leaves our protected environment.
• No third-party sharing: We do not share customer data with third-party LLM providers or use this data to fine-tune or train models. Your data remains exclusively yours.
• Stringent compliance: Our systems adhere to stringent security standards and compliance measures. We maintain SOC 2 Type 2 compliance, which is regularly verified by independent third-party audits.
• Data minimization: Command only accesses the data it needs to fulfill your queries and execute your commands. We apply the principle of least privilege to ensure that data exposure is minimized.
• Encryption: All data in transit and at rest is encrypted using industry-standard protocols.
• Role-based access controls: We implement strict access controls to ensure that only authorized personnel can access system components, and all access is logged and audited.

We believe that powerful tools do not have to compromise on security. With Command, you can harness the full potential of your network data while maintaining the highest standards of privacy and security.

A new way forward

Command represents a shift in how we interact with and manage network infrastructure. Unlike traditional software that requires users to adapt to its interface and functionality, Command adapts to you. It is not just a tool; it is a collaborative partner that understands your intent and generates custom software solutions at your request.

Where traditional software offers a fixed set of features and dashboards, Command creates tailored interfaces and visualizations in real-time. It is the difference between using a pre-built, view-only dashboard and having a skilled developer instantly craft exactly what you need, when you need it.

Command makes it easy for our customers and partners to have better visibility and control, regardless of the degree of their networking expertise.

For the rest of the year, we will introduce more ways to extend Command's capabilities and features. Our goal is to make our networks even more reliable, secure, and performant. This is the lens through which we built Command - only an extrapolation of the ethos used to build all of Meter’s products and services to date. With Meter, customers should have infrastructure that makes their organizations better.

Command will be available on all current and future Meter Networks at no extra cost. Customers and partners are being onboarded now. To learn more, request a demo today or watch our on-demand demo.