Private Data Verification for AI: Space and Time
Learn how Space and Time Enterprise uses Proof of SQL to verify AI calculations on private business data, and where the technology’s limits remain.

Space and Time Wants AI to Use Business Data Without Seeing It
Businesses want AI agents to work with internal records, but handing out broad access can quickly turn a useful workflow into a data-security headache. Space and Time Enterprise is built to separate those two concerns: an AI application can show that a calculation was done correctly without being given the underlying database records.
The platform, launched by the team behind the Microsoft-backed Space and Time project, uses Proof of SQL to verify database queries. Its launch partners include Maple Finance, Indomobil, Trenez, and The Data Foundation. Companies can run the software on their own servers, and they don't need to operate a blockchain to use it.
That separation matters. The product isn't about making bad data "true," and it doesn't replace normal access controls. It targets a narrower question: can a company let software use or report on sensitive data while making the computation independently checkable? This article breaks down how the system works, what it can and can't prove, and why enterprise adoption may be worth watching beyond crypto circles.
What Space and Time Enterprise does
Space and Time Enterprise is designed to prove that a database calculation was performed correctly without exposing the records used to produce it. The company says an AI application, auditor, or other stakeholder can check the result without being granted direct access to the underlying database.
At the core, it's a distinction between access to information and evidence about a computation. A company might want an AI agent to calculate a figure from customer, financial, or operational records. But that doesn't automatically mean the agent needs permission to inspect every record behind the figure. Space and Time's approach is to provide a cryptographic proof that the supported query ran correctly against a defined set of data.
The product is built on Proof of SQL. Space and Time says it works with Google Cloud's BigQuery, and that Enterprise can now run on a customer's own servers. The company also says deployment doesn't require a blockchain, specialized hardware, or an external proving service.
The launch partners named by the company include Maple Finance (an onchain asset manager), Indomobil (an Indonesian vehicle maker and distributor), Oracle software consultancy Trenez, and AI data network The Data Foundation. Partner announcements can be a useful signal of interest, but they don't, on their own, show how widely the software is being used in production. That's something teams should look at when evaluating any enterprise launch.
Space and Time's broader ecosystem also plays a role in the story. The project runs SXT Chain, which it describes as a decentralized network intended to provide verifiable data for areas including DeFi, tokenized assets, and stablecoins. Enterprise customers can still use the software without adopting that network first.
For practical reasons, that's a reasonable product choice. Requiring companies to move sensitive business data onto a public blockchain would be a high barrier for many organizations. Keeping computation inside a company-controlled environment lets teams test verifiable processing before blockchain operations become part of the initial rollout.
How Proof of SQL verifies a calculation
A database query takes records and applies steps to them - filtering, joining, counting, summing, or otherwise transforming the data. In a typical setup, the organization running the query is also the one expected to stand behind the result. A recipient may have to trust the operator, inspect the database directly, or rerun the computation independently.
Proof of SQL changes how verification works. Space and Time says the system produces a proof that a supported query was computed correctly on a given set of records. A verifier can check that evidence without receiving the records themselves. The goal isn't to publish the database - it's to make the calculation easier to audit.
A simplified example: an AI workflow might need a total derived from a company's private transactions. The organization can keep those transaction records in its environment, run the supported query, and share the result along with the proof. The receiving application or reviewer then checks the proof instead of being granted broad database access.
That can reduce the amount of trust required in the component that performed the calculation. It doesn't remove trust everywhere. A verifier still needs to understand which query was run, which data set the proof refers to, and whether the result matches the business question. And the organization's existing controls still determine who can initiate queries and what outputs are allowed to leave the environment.
Performance is part of the pitch too, but it comes with caveats. Space and Time CEO Nate Holiday said GPU-accelerated, supported queries across millions of rows can be run and proven in under a second. Real speed will depend on the query, the hardware, and the dataset, so the claim shouldn't be treated as a blanket promise for every workload.
The biggest limitation is about data quality. A proof can show that a calculation was performed correctly on the records it was given. It can't prove the records were accurate when entered. As Holiday noted, incorrect entries still need to be caught through normal business data controls. Verification can strengthen evidence about what data was used and how it was processed, but it can't replace controls around data collection and correction.
In a real deployment, you also have to define the verification "contract" clearly: the query, the data scope, the proof, the output, and who is responsible for validating each piece. If those details are fuzzy, even a technically valid proof may not help an auditor or business user.
Why verifiable data matters for AI and business
AI agents take an old problem - data access - and make it bigger. Companies want software to answer questions, generate reports, and run workflows using internal information. Broad access can make systems easier to build, but it also raises the stakes if something goes wrong: a compromised system, a flawed permission model, or an unintended data transfer.
Space and Time's argument is that an agent may only need the result of a computation, not unrestricted access to every record behind it. That's a solid design principle. Still, it isn't a complete security model. Organizations also have to decide what tasks an agent can request, what data those tasks can use, and what the result itself reveals.
This also applies beyond AI. Auditors, business partners, and compliance teams often need to validate figures without receiving an organization's full underlying dataset. If a company can provide checkable evidence for a result, it may be possible to reduce how much raw information gets shared. But whether that's useful in practice depends on how the proof fits into existing reporting and review processes.
Holiday said the company is working with customers in construction, engineering, and manufacturing who want agents, reporting tools, and compliance teams to work from the same business records. Those industries often rely on complex operational systems, where teams have to reconcile data across workflows. A shared, verifiable calculation could reduce disagreements about how a figure was produced - but only if the data definitions and query logic are aligned in the first place.
There's also a governance upside to separating data access from computation verification. Instead of granting an AI tool wide database permissions because it needs one metric, an organization can ask whether it can expose a narrower output and a proof. That can support least-privilege designs. It doesn't mean every AI workflow should use this approach. Some tasks genuinely need access to detailed records, and others may not justify the extra verification step.
Key takeaways for evaluating the use case:
- Identify the calculation an agent or reviewer needs, rather than starting with a broad request for database access.
- Check whether the query is supported and whether the intended recipient can verify the proof.
- Keep data-quality controls separate from computation verification; each covers a different failure mode.
- Test what the result and related metadata could reveal, even if the source records stay private.
- Weigh verification overhead against the financial, regulatory, and operational cost of sharing raw data.
The approach tends to work best when independent verification is genuinely valuable and direct data sharing would expose meaningful risk. It's less compelling when the underlying data is low-risk, the computation is easy to reproduce, or the proof adds complexity without changing the decision.
What enterprises should assess before deployment
If a company is considering Space and Time Enterprise, it should start with a real workflow - not a general promise of "private AI." Pick a calculation that currently forces someone (a person or a partner) to trust the system producing it. Then map the responsibilities end to end: data, query, output, and verification.
Start with the data boundary
First, identify where the records live, who controls the environment, and what systems can request a query. Space and Time says businesses can run Enterprise on their own servers. That can help keep infrastructure under company control, but it doesn't answer every security question. Teams still need to review deployment configuration, credentials, logging, network boundaries, and incident procedures.
The same goes for what leaves the system. A proof may avoid exposing the underlying records, but a query result can still be sensitive. Repeated queries, narrow filters, or small group totals can sometimes leak more than a single output suggests. Organizations should test the actual workflow and set policies for output size, query frequency, and approvals where it makes sense.
Validate the query and the proof process
A proof only matters if the verified computation matches the business rule you care about. Data owners, application engineers, and audit or compliance staff should agree on how the query is defined. Confirm what query types are supported and how changes to query logic are reviewed. A proof for the wrong query doesn't produce the right business outcome.
Teams should also test performance with representative data and hardware. The "sub-second" claim for certain GPU-accelerated queries over millions of rows is a vendor statement with specific workload dependencies. It isn't a substitute for benchmarking against the company's own query patterns, concurrency expectations, and service-level requirements.
Keep accountability explicit
Verification doesn't automatically decide who is responsible when something goes wrong - bad source data, unsafe agent behavior, or an incorrect business rule. Those responsibilities have to be assigned. Define who approves data sources, who can trigger agent workflows, who reviews exceptions, and what happens when a proof fails or a result is challenged.
A practical pilot should measure more than speed. Track how much data access is avoided, how hard it is to validate the proofs, whether the workflow fits existing controls, and what extra operational burden gets added. If the system adds a cryptographic step but doesn't meaningfully improve privacy, auditability, or trust, it may not be worth maintaining.
What the launch means for SXT and crypto adoption
The enterprise product stands out partly because it can be used without a blockchain. That lowers the adoption threshold for businesses that want verifiable computation but don't have a reason to run a decentralized network. It also means the enterprise value should be assessed on its own terms - not folded into a token or chain narrative by default.
Space and Time raised $20 million in a 2022 strategic funding round led by M12, Microsoft's venture fund. The company has also built other products, including Dreamspace, an AI-powered tool created with Microsoft Azure AI services for creating and deploying onchain applications. Its cryptography work connects beyond Space and Time's own network as well: Holiday said Microsoft's Nova project includes Blitzar, a Space and Time cryptographic acceleration library, and the team's work on the Dory commitment scheme contributed to a16z crypto's Jolt proof system.
Those connections suggest the company's work sits across enterprise software and crypto infrastructure. But they don't, by themselves, prove broad commercial adoption - or that a token is required for the enterprise product to be useful. That distinction matters both for people evaluating Space and Time as a technology provider and for those thinking about it as a crypto investment.
Space and Time also runs SXT Chain, which it describes as a decentralized network for verifiable data used by DeFi, tokenized assets, and stablecoins. Holiday said enterprise customers could deploy the product in their own environments, with the network becoming relevant when their applications need to connect to onchain markets. He also said those workloads would be paid for through Space and Time.
That points to one possible path: a business starts with private, locally deployed verification, then moves to decentralized infrastructure when it has a real need to interact with onchain markets. It's a more grounded route than expecting every enterprise customer to adopt a token or blockchain from day one. The open question is whether enough workloads will actually make that transition - and whether the network offers a clear operational advantage once they do.
For crypto watchers, the launch is therefore best read as an example of infrastructure meant to bridge controlled business data and onchain applications - not as proof that enterprise adoption automatically drives token demand. The value to customers and the economic role of SXT are related topics, but they aren't the same question.
Conclusion
Space and Time Enterprise aims at a specific problem - how to let software use private business data without handing every application unrestricted access to the records. Proof of SQL provides a way to verify calculations, while data-quality controls, query governance, and output security remain the organization's responsibility.
For companies considering the approach, the right test is a real workflow with clear requirements for exposure and auditability - not a broad "put AI and blockchain everywhere" directive. Start with one calculation, confirm what the proof actually establishes, and compare the operational cost with the risk of sharing the data directly.