Inspiration Companies make tons of massive calls every single day, but all the context is buried across random Docs, Slack channels, Jira tickets, and emails. We didn't want to just build another wrapper or RAG bot that spits out generic AI answers.
We asked ourselves: what if a team could actually track why a choice was made, what data backed it up, what action got taken, and whether it actually worked out? That’s why we built XPrize Decision Intelligence—basically a system that turns scattered docs into actual decision memory so teams stop making the same mistakes.
What it does It maps out the entire life cycle of a decision. Instead of just grabbing raw text, it figures out where the data came from, if it's reliable, and how it connects to everything else.
It links everything together into a graph:
- The setup: Evidence, Reasoning, Alternatives considered
- The execution: Approvals, Actions taken
- The aftermath: Outcomes, What changed, Lessons learned, Precedent
Say there's a production outage. The platform pulls logs, chat history, and tickets to figure out what everyone knew at the time, checks it against company policy, and records the fix. The next time a similar incident hits, instead of starting from scratch, it pops up:
- What we knew back then
- What we did & what happened
- What we learned & what to do now
How we built it We split the architecture into four core layers:
- Information & Reasoning: Pulls in raw evidence, tracks provenance, and builds out the decision graph with vector embeddings.
- Memory Layer: Stores past outcomes and validated precedents.
- Agent Layer: Runs AI agents to parse policies, analyze evidence, and handle root-cause investigations.
- Infra Layer: To actually scale the AI, we set up a Kubernetes cluster running Ray for distributed jobs, vLLM / SGLang for fast inference with continuous batching, and KV-cache management. We used CUDA acceleration, tensor/pipeline parallelism, and plugged in Prometheus + OpenTelemetry to keep everything observable.
Challenges we ran into
- Data vs. Ground Truth: Just because a doc says something doesn't mean it's true. Handling conflicting info from different tools and tracking when something was known was a huge headache.
- Connecting Logic to Actions: Getting the AI to give a recommendation was easy; making it track the full chain (the evidence, the rejected alternatives, human approval, and the final result) took a lot of extra wiring.
- Infrastructure Overhead: Balancing enterprise-level graph logic with heavy GPU orchestration (autoscaling, scheduling, and model serving) got tricky fast.
Accomplishments that we're proud of
- Hooked up a full end-to-end pipeline from raw evidence all the way to post-incident tracking.
- Built validated precedent retrieval—instead of just pulling "similar text" via simple vector search, the system pulls the full historical context (what was known, what was decided, and how it turned out).
- Built a production-style model-serving stack complete with GPU scheduling, agent orchestration, and cost/inference monitoring.
What we learned
- Vector DBs alone aren't enough for real organizational memory; semantic search misses crucial context like timing, causality, and outcome.
- The best AI tools aren't just the ones that generate pretty text—they're the ones that make complex decisions audit-friendly, traceable, and repeatable.
- The outcome of a past decision is the most valuable input for the next one.
What's next for XPrize We’re taking this from hackathon project/prototype to production. We're targeting high-stakes use cases first—like incident response, procurement, and compliance audits. We're building out more data connectors, tuning the policy engine, and scaling up the distributed inference setup.
The end goal? An OS for enterprise decisions so companies never have to relearn the exact same lesson twice.
Log in or sign up for Devpost to join the conversation.