Inspiration
Supplier reviews rarely happen in one clean document. The answer is usually scattered across agreements, work orders, invoices, service terms, change requests, acceptance records, and email threads.
A model can summarize those files—or even reason across them in a single response. The harder problem is turning those relationships into a review state that remains traceable, makes unresolved facts explicit, and can be safely recomputed when new information arrives.
SecondLook was built to do that.
What it does
SecondLook turns a supplier document package into a source-grounded obligation graph.
It identifies parties, facts, obligations, conditions, exceptions, dependencies, and proposed actions. Every finding used by the review is tied to an exact source passage.
When the documents do not establish a fact that matters to the review, SecondLook does not guess. It exposes that fact as a focused question for a human reviewer.
Once the reviewer answers, the graph is recompiled and the review is evaluated again. The resulting state is stored as a controlled internal review action, while the final business decision remains with a person.
How it was built
The workflow has four main layers:
- Documents are ingested, with Nutrient DWS providing the PDF and spatial-text extraction path.
- An AI model proposes a package-specific graph of facts, obligations, conditions, exceptions, and dependencies.
- Deterministic admission checks reject unsupported evidence, invalid relationships, and malformed model output.
- The validated graph is compiled into a deterministic decision layer. Human answers update unresolved facts and trigger a fresh evaluation of the review.
Xano provides the durable review-state and action boundary. Review actions are written through a controlled API workflow, then independently read back and verified against the state SecondLook intended to persist.
The browser interface exposes the result as an obligation map, cited evidence, focused reviewer questions, and the review actions currently available.
Challenges
The hardest part was separating AI interpretation from authority.
SecondLook needs a model to interpret unfamiliar document packages, but model output cannot simply become system truth. Evidence must resolve back to the submitted documents, graph relationships must pass deterministic validation, and unusable model output must fail closed rather than silently entering the review state.
A second challenge was dealing with missing information. An absent fact is not automatically false, and guessing can change the outcome of a review. SecondLook therefore represents important unknowns explicitly and turns only decision-relevant ones into questions for a human.
The interface posed a different problem: a useful obligation graph can become too large to read. The UI groups related obligations and progressively reveals evidence and dependencies so a reviewer can follow one decision path without losing its provenance.
What I learned
The most useful division of labor was not “AI decides, human approves.”
AI is useful for interpreting unfamiliar documents and proposing structure. Deterministic code is useful for deciding what evidence and relationships are admissible and for controlling state transitions. Humans are needed where the documents themselves cannot establish an important fact.
That separation makes the system more useful than either a free-form model answer or a fully hand-authored rules engine.
What's next
SecondLook starts with supplier invoice and work-order exceptions.
The next step is to carry the same confirmed obligation state across later supplier events—such as amendments, renewals, exception handling, and audit requests—so each review can build on what has already been established instead of reconstructing the supplier context from scratch.
Source code: https://github.com/miemiemi2/secondlook
Log in or sign up for Devpost to join the conversation.