Reasoning Layer infrastructure for enterprise AI agents
Uvi is a Reasoning Layer platform built on a Decision Graph for enterprise AI agents.
AI Panel Score
6 AI reviews
Reviewed
Facts checked against uvi.io
Uvi works in two tiers. The first, the Topic Graph, indexes an enterprise's entire dataset and links documents to one another through explicit and implicit references, such as a ticket connected to a pull request, the code it touched, and the Slack thread that discussed it. It also resolves entities across tools so a single person maps to one identity everywhere, and it enforces document-level permissions on every node. The second tier, the Decision Graph, encodes a company's private chain of decisions, their owners, triggers, and blockers, so an agent can ask a question like "What's blocking checkout v2 from shipping?" and get back the specific open decisions, their owners, and current status rather than a pile of documents to read.
The website positions Uvi against enterprise search platforms such as Glean, vector databases, RAG frameworks, and traditional knowledge graphs: search returns links, while Uvi's reasoning layer returns the decision chain itself. It deploys on-premise or inside a customer's VPC with zero data egress, works with any LLM (OpenAI, Anthropic, Llama, Mistral) and any agentic framework (LangChain, AutoGen, CrewAI, or custom setups), and enforces existing role-based access controls natively at retrieval time rather than after the fact. Uvi also publishes an open Decision Graph schema specification and a reference MCP server under Apache 2.0 for teams building their own implementation.
The company reports that the approach reduces tokens used per agent interaction and lowers retrieval latency compared with traditional RAG pipelines, framing this as a way for enterprises capping LLM budgets to unblock teams without raising the cap. Rollout is handled by a Forward Deployed Agent, described as a specialist in ETL and data science, who works with a customer's tech lead to build the Decision Graph end-to-end, with production deployment cited at 2-4 weeks.
Uvi is built for large engineering organizations, typically cited as 100+ engineers, where decisions are scattered across many systems and tools. Production customers named on the website include Global-E (NASDAQ: GLBE) and Melio. The site does not publish specific pricing plans or figures.
Delivers quicker response times than traditional RAG pipelines by handing agents the right context directly instead of requiring iterative searching.
Reduces tokens consumed per agent interaction by returning one precise structured answer instead of dozens of speculative retrievals, lowering measurable LLM spend.
Models decisions as first-class nodes—owner, trigger, blockers, and dependencies—encoded across an organization's tools and private vocabulary to represent how the company actually decides, ships, and unblocks.
Resolves entities across tools so a single person or object maps to one consistent identity everywhere in the graph.
Indexes the entire enterprise dataset and links every document to every other through explicit and implicit references (ticket ↔ PR ↔ code ↔ Slack thread) to form the underlying plumbing beneath the Decision Graph.
Provides an open, Apache 2.0 licensed Decision Graph schema specification and reference MCP server that teams can implement against to build their own version.
Lets any AI agent query the Decision Graph directly in GraphQL and receive a structured chain of decisions rather than a list of documents.
Integrates with any LLM (OpenAI, Anthropic, Llama, Mistral) and any agentic framework (LangChain, AutoGen, CrewAI, custom) so existing agents can plug into the graph.
Turns an agent's plain-language intent into a structured GraphQL query against the Decision Graph, acting as the Model Context Protocol interface to the reasoning layer.
Enforces existing role-based access controls and document-level permissions natively at retrieval time on every node of the graph, rather than post-hoc.
Deploys inside a customer's own premises or VPC with zero data egress, including support for air-gapped environments.
A specialist in ETL and data science sits with the customer's tech lead to encode decisions, owners, triggers, and blockers end-to-end, putting the Decision Graph into production in 2-4 weeks.
Uvi is enterprise infrastructure for large engineering organizations (typically 100+ engineers), deployed on-premise or in a customer VPC via a Forward Deployed Agent engagement. No public pricing is listed on the site; engagement is through a demo/contact process.
A decision graph instead of a document pile, if you've got 100+ engineers and patience for a build-out.
“Uvi skips the retrieve-and-hope model and models decisions themselves. The 97-of-100 benchmark against GPT-4.1 is compelling, but it's one vendor's own test at one customer.”
Two tiers here: a Topic Graph that links tickets, PRs, code and Slack threads, and a Decision Graph on top that tracks owners, triggers and blockers. That's a real architectural bet against the obvious alternative of enterprise search plus RAG, which hands you links instead of an answer. The GraphQL and MCP query interface is the kind of detail that suggests actual engineering, not a wrapper.
Forward Deployed Agent model means 2-4 weeks to production, but that's a services engagement, not a self-serve product. No public pricing, quote-only, built for orgs with 100+ engineers — this isn't a pilot-with-five-people tool.
Named customers: Global-E and Melio. Two logos. SOC 2 is in progress, not done, which matters if you're pushing code and Slack history into a third-party graph. On-prem and VPC deployment with zero egress covers the biggest objection. Apache 2.0 schema is a smart hedge against lock-in fear.
The 97-of-100 win against MCP-enabled GPT-4.1 at Global-E is a specific, named benchmark most document-search tools can't point to.
SOC 2 is listed as in progress rather than complete, which is a real gap for a product ingesting code and Slack data.
2-4 week production timeline via a Forward Deployed Agent is fast for enterprise infrastructure but still a services-led rollout, not instant.
A decision-chain answer instead of a document list is a genuine step forward for agent tooling, not just a cheaper RAG pipeline.
Open schema spec and reference MCP server under Apache 2.0 signal real engineering investment, though I couldn't find docs or a changelog to confirm shipping cadence.
Large engineering organizations with 100+ engineers drowning in scattered decisions across tickets, PRs and Slack.
Skip it if you need a self-serve tool you can pilot with five engineers next week.
A decision graph is the right unit of knowledge for engineering orgs that have outgrown search.
“Uvi models decisions, owners, and blockers as graph nodes instead of indexing documents into a search layer. That's the correct taxonomy shift for knowledge management in agentic workflows, but it asks a KM function to take on live data modeling, not content curation.”
Most enterprise search and knowledge graph tools still organize around the document as the atomic unit. Uvi's Decision Graph treats the decision itself as the node, with owner, trigger, and blocker as first-class attributes. That's a genuine taxonomy upgrade for KM teams who've spent years fighting the gap between 'here are twelve related tickets' and 'here is who is blocking this and why.' The Topic Graph underneath, resolving a ticket to its PR to its Slack thread, is the kind of cross-system entity work most KM programs attempt manually in a wiki and never finish.
The catch is that this isn't a content governance tool, it's a live operational model of engineering decisions. That shifts KM ownership toward tech leads and away from librarians and taxonomists, which changes who you need on staff to keep the graph honest. Our discipline has spent a decade pulling SMEs into curation; this pulls engineering further out of it.
GraphQL and MCP access fit how agent-building teams already query things, and LLM-agnostic design avoids betting the taxonomy on one model vendor. Three-year question: does the Decision Graph stay a living model of the org, or calcify the day the Forward Deployed Agent leaves.
Positioned explicitly against search-and-link platforms like Glean by returning decision chains instead of document lists, a clear and defensible wedge, though still unproven at scale with only a couple of named production deployments.
Fits engineering knowledge work well via Claude Code and Cursor integration, but KM teams outside engineering have no clear entry point into the Decision Graph.
Querying via GraphQL or MCP and plugging into LangChain, AutoGen, or CrewAI means it sits alongside existing agent tooling rather than forcing a rebuild.
A graph that encodes 'how the company actually decides' becomes a durable asset only if someone keeps feeding it after the initial 2-4 week build, a maintenance question the model doesn't answer on its own.
Modeling decisions with owners, triggers and blockers as graph primitives goes past retrieval into organizational modeling, which is a deeper craft ceiling than most search tools attempt.
Engineering organizations with 100+ engineers who need agents to reason over who decided what and what's blocking shipment, not just retrieve documents.
Avoid if your knowledge management mandate spans non-engineering domains where decisions aren't tracked in tickets, PRs, and code.
No number on the page. 97/100 benchmark, zero dollars attached.
“Contact-sales only, no tiers, no floor price. Math is impossible to run before a call.”
No pricing plan here. One line: Contact Sales. Can't build a TCO model off that.
What I can model: a Forward Deployed Agent engagement, 2-4 weeks to production. That's services cost on top of license, undisclosed. For 100+ engineer orgs — the stated target segment — figure a build cost that rivals the first year of license fees. Category norm for white-glove enterprise rollouts is 20-40% of year-one contract value in services. Nothing here confirms or denies that.
The 97-of-100 benchmark at Global-E is the closest thing to an ROI hook. It's a performance claim, not a cost claim. Token reduction and latency gains are mentioned too, which matters for teams with LLM budget caps — but there's no metered rate to multiply against. SOC 2 in progress means security review timelines, not dollars, but it'll slow procurement on the way in.
SOC 2 still in progress and sales-led onboarding via Forward Deployed Agent add friction before invoice one.
No term length or renewal clause visible; enterprise infra deals usually mean annual commits, unconfirmed here.
Single tier, Contact Sales, no seat count or floor figure published.
97/100 benchmark win plus stated token and latency reductions give a measurable hook, even without dollar figures attached.
Forward Deployed Agent engagement implies real services spend with no rate card to size it.
Finance teams at 100+ engineer orgs who can get a quote and have budget authority to negotiate services cost directly.
Avoid if you need a published number to clear a budget gate before the first sales call.
A Decision Graph is only as current as whoever maintains it after the Forward Deployed Agent leaves
“Uvi's GraphQL/MCP query model is a genuine fit for how agent-building teams already work, not a bolted-on chat box. The open question for anyone running longitudinal research is what the graph looks like six months post-rollout, once the specialist team moves to the next account.”
As a research tool, the interesting claim here isn't retrieval speed, it's provenance: a decision node carries an owner, a trigger, a blocker. That's closer to how I'd want to trace an institutional decision than a ranked list of Slack threads. The GraphQL interface means I can write a repeatable query and rerun it as the org changes, which beats re-prompting a search bar every time.
The open question is corpus drift. Entity resolution across tickets, PRs, code, and Slack is the hard research problem — getting it right once at Global-E is different from keeping a 100+ engineer org's decision chain accurate a year later as ownership rotates and tools get swapped. I found nothing describing how the Topic Graph gets re-indexed or re-verified after the initial 2-4 week build.
Documentation-wise, the public blog reads like it's written for buyers evaluating the pitch, not researchers trying to replicate the 97/100 benchmark methodology. I'd want the actual query set, not just the win rate, before citing it.
The decision-chain answer format is a real upgrade over document lists, but day-3 value depends entirely on how well the initial Forward Deployed Agent build captured tribal context.
I could only find the blog; the benchmark numbers are cited without a published query set or methodology to let anyone verify the 97/100 result independently.
No self-serve path and a mandatory specialist engagement means any iteration on the graph's structure likely routes back through that same team, not the researcher.
The Apache 2.0 schema and reference MCP server suggest real depth for teams wanting to extend the graph, though discoverability of that path from the main site is thin.
Querying via GraphQL or MCP against existing agent frameworks like LangChain or CrewAI fits how technical research workflows are already built, not a new habit layered on top.
A research or knowledge team at a large engineering org that needs to trace decision provenance across tools and can staff an ongoing relationship with Uvi's deployment team.
Avoid if you need to independently audit or reproduce the benchmark claims before trusting the system for research citations.
Nobody self-serves their way into this one. You get a Forward Deployed Agent instead.
“Uvi isn't a tool you poke at for ten minutes to get a feel for. It's infrastructure someone builds for you, which flips every normal 'day one' question on its head.”
You can't really do a day-3 test on Uvi the way you'd test a normal app, because there's no app to open yet. There's a Forward Deployed Agent who sits with your tech lead for 2-4 weeks building the Decision Graph before anyone queries anything. That's a wildly different onboarding model than click-signup-and-explore, and whether it feels like a relief or a stall depends entirely on how much you trust that specialist.
Once it's running, the interaction surface is GraphQL and MCP, not a dashboard. So 'daily polish' as I'd normally judge it — empty states, loading spinners, mobile check-ins — mostly doesn't apply, because the people touching this day to day are engineers querying through Claude Code or Cursor, not staring at a screen Uvi built.
That's the tradeoff: you're not buying a product you learn, you're buying an integration someone else assembles for you, on orgs of 100+ engineers. Fine if you've got the headcount and patience for that. Rough if you wanted something you could just try first.
There's no end-user interface to sweat details on — the surface is GraphQL/MCP, so 'polish' lives in query ergonomics I can't see.
An Apache 2.0 schema and reference MCP server give technical teams something concrete to study and extend over months, not just a locked product to click through.
Platform is listed as web only, and the whole model is engineers querying a graph, so mobile isn't really part of the design conversation.
A 2-4 week Forward Deployed Agent build replaces self-serve onboarding entirely, which is homework by design, not welcome.
On-prem/VPC with zero data egress and RBAC enforced at retrieval time suggest a team that thought hard about failure modes, even without visible uptime data.
Large engineering organizations with 100+ engineers who can commit to a multi-week Forward Deployed Agent build before seeing value.
Avoid if you want to try something yourself this week rather than commission an infrastructure build.
Naboo rebranded to Uvi. Name changes make me check the fundamentals twice.
“97 of 100 queries beat MCP-enabled GPT-4.1 at one customer, Global-E, on an undisclosed methodology. Strong claim, thin proof surface.”
A single benchmark number carries a lot of weight on this site. 97/100 vs GPT-4.1 at Global-E sounds concrete, but there's no published query set, no third party replicating it. I've seen vendors lead with a head-to-head stat before it's independently checked — sometimes it holds, sometimes it quietly disappears from the homepage a year later.
The rebrand itself (Naboo to Uvi, redirect in place) isn't disqualifying. Companies rename. But paired with 'SOC 2 in progress' and only Global-E and Melio named as production customers, it reads like an early-stage story still being written, not an established one.
The Apache 2.0 schema is a genuine hedge against lock-in — rare in this category, and worth crediting. Whether the core graph-building logic ports anywhere near as cleanly is a separate question nobody's answered yet.
Framing itself against enterprise search and vector databases as returning decisions instead of links is a clear, specific contrast.
The open Apache 2.0 schema and reference MCP server give a real fallback path if the vendor relationship ends.
SOC 2 still in progress and a recent rebrand from Naboo are the kind of signals I'd want more time to watch settle.
The 97/100 benchmark is specific but unverifiable without a published methodology or query set.
Two named customers, Global-E and Melio, and one internal benchmark is a small sample to back an infrastructure-wide claim.
Large engineering orgs willing to run their own diligence on an unverified benchmark claim.
You need a completed SOC 2 report or a multi-customer track record before engaging procurement.
Common questions answered by our AI research team
Uvi's Decision Graph indexes an organization's code, tickets, pull requests, docs, Slack, runtime, and internal services, modeling who decided what, what triggered each decision, and what blocks or depends on it — linking events like a closed ticket to its merged PR and resulting feature flag state.
AI agents query Uvi's Decision Graph via GraphQL or an MCP server, receiving a structured answer about a decision chain instead of a list of search results.
Uvi integrates with coding interfaces including Claude Code and Cursor, alongside agent sessions and your own custom-built agents.
Yes, Uvi supports on-prem deployment, listed as one of its core layers alongside its semantic layer and knowledge graph capabilities.
In a 100-query head-to-head benchmark at Global-E, Uvi won 97 of 100 queries against MCP-enabled GPT-4.1.
Uvi builds Reasoning Layer infrastructure for enterprise AI agents, turning code, tickets, and internal knowledge into a structured Decision Graph.
