Rockfish Data is a synthetic data platform for enterprise time-series and tabular data. Founded in June 2022 on research from Carnegie Mellon University, Rockfish generates synthetic operational data — telemetry, transactions, event streams — that teams use to train and test ML models and to evaluate AI agents. The platform is modular: four modules that run on their own or chain into an end-to-end pipeline.

Rockfish has four modules. DataFuel generates synthetic time-series from a sample of your production data. SchemaFuel generates from a schema definition alone, with no source data required. Scenario Studio injects edge cases, rare events and incident patterns into a dataset or model output. AgentFuel turns those scenarios into prompts, queries and expected responses for scoring an AI agent.

Rockfish Data was founded in June 2022 by Dr. Muckai Girish, Dr. Vyas Sekar, Dr. Giulia Fanti and Nathan Haugo. Girish is CEO; Sekar and Fanti are Carnegie Mellon faculty whose research on deep generative models underpins the platform. Sekar serves as Chief Technologist and Fanti as Chief Scientist.

Rockfish Data works with enterprises in observability, telecom, networking and security, alongside public sector agencies including the U.S. Army and the Department of Homeland Security. Published customer work includes Conviva, which used AgentFuel to evaluate its NEXA agent, and Rento Perú, which lifted same-month conversion to 24% using synthetic booking data.

Synthetic data is artificially generated data that preserves the statistical patterns of a real dataset without containing any real records. A generative model learns the distributions, correlations and temporal behaviour of the source data, then samples new records that behave like the original. Teams use it when real data is too sensitive, too scarce, or too imbalanced to work with directly.

Synthetic data is used for ML training and testing, AI evaluation, and data sharing across silos. It fills gaps that real data cannot: testing a pipeline against failure conditions that have not occurred yet, training on a class that appears in a fraction of a percent of records, sharing a dataset with a partner who cannot see production, or building an evaluation set where the correct answer is known in advance.

Synthetic data is generated by rule-based methods, statistical models, or machine learning models. Rule-based generation follows constraints you specify and needs no source data. Statistical methods reproduce properties such as means and correlations. Model-based approaches — GANs, diffusion models, transformers — learn from a real dataset and sample new records from what they learned. This gives the highest fidelity, but requires source data to train on.

No. Masking and anonymization transform real records, so every row still traces back to a real subject. Synthetic data generates new records from a learned model, so there is no one-to-one mapping to any individual. Masking preserves the original rows; synthesis preserves the original patterns. The two are often used together, and neither is automatically compliant on its own.

Not always. Sample-based generation learns from a slice of real production data and reproduces its behaviour, which gives the closest match. Schema-only generation works from a table definition or a plain-language description of what the data should contain, which is the route when the real data cannot be accessed at all or does not exist yet. Rockfish supports both, through DataFuel and SchemaFuel respectively.

Synthetic time-series data is generated data that preserves how values change over time — trends, seasonality, autocorrelation, and the timing relationships between correlated signals — not just the distribution of individual values. A synthetic CPU metric with the right average but the wrong burst pattern will not exercise an anomaly detector, which is why time-aware structure is the whole point.

Because the ordering carries the information. In tabular data, rows are independent, so a generator only has to match column distributions and cross-column correlations. In time series, each point depends on the points before it, signals correlate with each other across lags, and sequences can run to millions of steps. A generator that treats each timestamp as an independent row destroys exactly the structure that made the data worth modelling.

Synthetic telemetry data is generated operational data that mimics what running systems emit — network performance counters, device metrics, container resource usage, application traces. It is used to test monitoring and anomaly detection at scales and failure conditions that would be impractical or risky to reproduce in a live environment. Rockfish has generated synthetic telemetry for Wi-Fi networks, Kubernetes pod metrics and ERCOT electricity prices.

By conditioning the generator on the event rather than sampling from the overall distribution. If a failure mode appears in a handful of records, a model trained to reproduce the whole dataset reproduces that rarity too, which is useless for testing. Scenario injection asks for the rare case specifically and at volume — an incident window, a sensor drift, a congestion event — so the test data contains what you actually need to test against.

Yes, and it is one of the strongest use cases. Synthetic data lets you construct inputs a model has not seen — traffic spikes, distribution shift, a device class you have not deployed yet — and observe how the system behaves before those conditions arrive. Because the conditions were generated deliberately, the correct behaviour is known, so failures are measurable rather than merely noticed.

Scenario injection is the process of adding specific, labelled conditions into an otherwise realistic dataset: incidents, anomalies, drifts, and edge cases placed at known times in known signals. It converts a baseline synthetic dataset into test data with a built-in answer key, which is what makes automated scoring possible. In Rockfish this is Scenario Studio, which runs on either a trained generative model or an existing dataset.

AI agent evaluation is the practice of measuring whether an autonomous AI system produces correct results on tasks with verifiable answers. It differs from model benchmarking in scoring an entire multi-step workflow — the queries issued, the tools called, and the final answer — rather than a single model response, and in using tasks drawn from a specific domain rather than a public question set.

Because benchmarks test different questions on different data. Generic evals use flat or invented data with no incident windows, correlated signals or event sequences, and they ask lookups and averages rather than the incident-aware questions real users ask. In Rockfish's testing, agents scoring 73% on benchmark-style tasks dropped to 10–20% on domain-specific, incident-focused queries.

Because there is usually no answer key. When an agent reports a figure from production data, nobody knows what the right figure was, so the answer can only be judged for plausibility — and a confidently wrong number looks exactly like a correct one. An agent that answers 783 when the true value is 398 ships silently unless something is grading it against ground truth.

AgentFuel is Rockfish Data's module for building evaluation suites for AI agents that analyze time-series data. It takes a schema and your domain context, generates a labelled time-series dataset with scenarios injected, and produces question-and-answer pairs with known ground truth — then scores the agent's answers against them and returns a scorecard. The method is described in the AgentFuel paper on arXiv (2603.12483).

It is a dataset where the correct answer is established by construction rather than by labelling after the fact. Instead of collecting real data and paying reviewers to annotate it, you generate data with the pattern already planted — a throughput drop starting at a known timestamp on a known device — so every agent response can be scored automatically against what was put there.

LLM benchmarks score a model on a fixed public question set, which measures general capability and degrades in value as models train on it. Agent evaluation scores a specific deployed system on tasks from your own domain, including the data it reads and the tools it calls. A model at the top of a public leaderboard can still fail on your telemetry, which is what makes domain-specific evals necessary rather than optional.

In three steps. First, bring a schema or data sample, the agent to be tested, and your business context. Second, a time-series dataset is generated for your domain, scenarios are injected, and question-and-answer pairs with ground truth are produced. Third, you get labelled datasets, the eval pairs, and a scorecard showing where the agent failed — versioned, so you can track regressions release over release.

On three axes that trade off against one another: fidelity, whether the synthetic data reproduces the statistical properties of the source; utility, whether a model trained on it performs comparably on real data; and privacy, whether individual source records can be re-identified. Rockfish measures all three against industry-standard benchmarks, because a single composite score hides the trade-off you actually need to see.

Fidelity measures how closely synthetic data matches the source distribution. Utility measures whether it works for the task you need it for. The two come apart often: a dataset can score well on distributional similarity and still be useless for training a rare-event detector, and a deliberately skewed dataset can have low fidelity and high utility for testing. Utility has to be measured on the downstream task, not on the data.

Synthetic data substantially reduces privacy risk because it contains no real records, but it is not automatically anonymous — a generator trained on sensitive data can memorize and reproduce it. Privacy therefore has to be measured on the output rather than assumed from the method, which is why Rockfish reports a privacy score alongside fidelity and utility. Rockfish learns patterns, not individuals.

No. Rockfish runs where your data lives — in your own VPC, on-premise, or as a Snowflake Native App — so generation happens inside your boundary and raw records never leave it. The model learns patterns from the sample and the synthetic output is what moves downstream.

Yes. Rockfish Data is SOC 2 Type II certified, independently audited.

Differential privacy is a mathematical guarantee that the output of a computation barely changes when any single individual's record is added or removed, quantified by a privacy budget usually written as epsilon. Applied to synthetic data generation, it bounds how much any one source record can influence the generated output, at some cost to fidelity.

Rockfish offers three deployment options: your own VPC, on-premise, or as a Snowflake Native App. In all three, generation runs where the data already sits, so source records stay inside your environment. This is usually the first question security review asks, and the answer is that Rockfish comes to the data rather than the reverse.

Yes. Synthetic data generated by Rockfish lands in Snowflake, Databricks, or an existing pipeline, and Rockfish is available as a Snowflake Native App so generation can run inside a customer's Snowflake account. There is no model lock-in — output is standard data usable by whatever trains or tests on it downstream.

Rockfish supports tabular and time-series operational data — telemetry, metrics, event streams, transactions and logs. Deployments have covered Wi-Fi network telemetry, Kubernetes pod metrics, financial transactions, booking records and ERCOT electricity market prices. Rockfish models are also published on Hugging Face under RockfishData.

You regenerate. Rockfish is built for continuously changing operational data, so when a schema, business logic or upstream model changes, the generation run can be repeated against the new shape rather than rebuilt. This matters most for evaluation data, which otherwise goes stale and stops testing the system as it currently exists.

Open-source libraries such as SDV give you generators for tabular data. Rockfish is built specifically for time-series and adds the surrounding workflow: scenario injection to plant the conditions you want to test, quality measurement across fidelity, utility and privacy, agent scoring, and enterprise deployment inside your own VPC or Snowflake account. The difference is less about the generator and more about everything that makes its output testable.

Rockfish offers free access to the platform, requested through the contact form on rockfish.ai.

There are three entry points: request free access to the platform, book a demo with the team, or start from the documentation at docs.rockfish.ai. For agent evaluation specifically, the AgentFuel one-pager and the arXiv paper cover the method before you talk to anyone.

Either a data sample or just a schema, plus the agent or model you want tested and enough business context to make the generated questions realistic. Schema-only is the lighter path when production data cannot be shared for a first evaluation, which is often what unblocks a security review.