AWS Builder Center
The Paper Got Retracted. Our AI Answer Didn't Get the Memo. — Building Origyn on AWS

The Paper Got Retracted. Our AI Answer Didn't Get the Memo. — Building Origyn on AWS

A research paper gets retracted. The AI answer that relied on it stays exactly the same. We built Origyn to change that — an evidence-memory layer that tracks the path from paper to claim to answer.

The Paper Got Retracted. Our AI Answer Didn't Get the Memo.

Building Origyn on AWS — an evidence-memory layer for research that remembers not just what an AI answered, but why it answered that way, and what should happen when the evidence changes.
Team: Bangalore Police Builders: Abdul Farooqui and Parth Malhotra College: International Institute of Information Technology Bangalore (IIIT Bangalore) Year: Pre-final year



Monday, the answer looked fine. Thursday, the paper was retracted.

Imagine this.
You upload a few research papers into an AI assistant. You ask a question. It gives you a neat answer with references. You use that answer in your notes, maybe in a literature review, maybe as the starting point for something more serious.
Three days later, one of those papers is retracted.
What happens to the answer?
Usually, nothing.
The answer does not wake up and say, “Small update: one of the things I relied on is no longer trustworthy.”
It just sits there. Calm. Polished. Completely unaware that the ground beneath it has moved.
That was the thought that eventually became Origyn.
Origyn is a memory layer for research evidence — a system that remembers not just what an AI answered, but where that answer came from, what supported it, and whether that support still holds.
At the centre of the product is a very simple chain:
Document → Claim → Answer
The idea sounds obvious once you see it. But while building, we realised that most AI research workflows are designed around generating the answer, not maintaining the relationship between the answer and changing evidence over time.
That difference became our whole project.



The problem is real, and research already shows why it matters

We did not want to build a hackathon problem that only existed because we needed something to demo.
So we looked at what happens to retracted research in the real world.
A database-wide study examined 7,813 retracted papers and 169,434 citations. Among 13,252 citation contexts made after retraction, only 5.4% explicitly acknowledged that the cited work had been retracted.
That means a paper can be formally retracted while its influence continues travelling through later work with very little visible warning.
A separate study of retracted systematic reviews found something similarly uncomfortable: of 954 citations to 128 retracted reviews, 60.8% were published after the review had already been retracted. Only a small fraction explicitly indicated the retraction.
So the basic problem existed long before generative AI:
knowledge changes faster than the things built on top of it.
AI adds a new layer.
A 2023 Scientific Reports study that tested ChatGPT-generated bibliographic citations found that, in its experimental setup, 55% of GPT-3.5 citations and 18% of GPT-4 citations were fabricated. Newer models have improved substantially, but the underlying lesson still matters: fluent output and trustworthy evidence are not the same thing.
We are not claiming that no research tool handles retractions. That would be wrong.
Crossref now exposes Retraction Watch information through its production REST API, and reference managers and scholarly systems can warn users when a source has been retracted.
But we kept coming back to another question:
What happens to an AI-generated answer that already used that source?
Which extracted claims should now be considered unsupported?
Which answer version is affected?
Can the answer be regenerated using the evidence that remains?
Should the original answer disappear, or should it remain visible as historical provenance?
And what if no trustworthy evidence remains at all?
Those questions felt much less solved.
So we decided to work on the consequence, not just the warning.



How we found Origyn

Our first ideation sessions did not begin with some grand research-integrity manifesto.
They looked more like this:
“AI that summarises X.”
“Agent that automates Y.”
“Upload a PDF and ask questions.”
After enough variations, we had a small graveyard of ideas that sounded useful but also felt suspiciously familiar.
So we changed the question.
Instead of asking:
“What else can we make an LLM do?”
we asked:
“What goes wrong around LLMs that still feels unresolved?”
That led us to hallucinations, provenance, stale context, research retractions, and the larger issue of evidence drift.
Then the core idea clicked:
What if the system did not just remember the conversation?
What if it remembered the evidence graph behind the conversation?
That became Origyn.



What Origyn actually does

A researcher uploads a paper.
Origyn stores the source, identifies whatever scholarly metadata it can, checks its status, and extracts claims from the document.
Those claims can then support AI-generated research answers.
But instead of treating the generated answer as an isolated blob of text, Origyn stores its lineage.
Conceptually:
Research Paper
↓
Extracted Claims
↓
Generated Answer
And once that relationship exists, Origyn can reason about change.
If a source becomes:
  • Retracted
  • Invalidated
  • Deleted
  • otherwise unusable
then the system can propagate the consequence downstream.
A claim that depended on that source can become Unsupported.
An answer that depended on that claim can become Evidence Changed.
The researcher can then regenerate the answer using only the evidence that is still usable.
If enough valid evidence remains, Origyn creates a new answer version.
If nothing usable remains, Origyn does something AI products are not always famous for doing:
it stops.
The state becomes:
No Usable Evidence
No confident paragraph invented to keep the interface looking helpful.
Sometimes the most trustworthy answer is that there is no trustworthy answer left.



A concrete example

Suppose a researcher has three papers:
  • Paper A supports Claim 1
  • Paper B supports Claim 2
  • Paper C supports Claim 3
Origyn generates Answer V1 using all three claims.
Later, Paper B is retracted.
Origyn does not rewrite history.
Answer V1 still exists because it was genuinely the answer produced at that point in time.
But the evidence behind it has changed.
So:
Paper B → Retracted
Claim 2 → Unsupported
Answer V1 → Evidence Changed
The researcher can regenerate.
If Papers A and C still provide enough usable evidence:
Answer V1
↓
Answer V2
V2 is generated from the remaining valid evidence.
Now imagine Paper A is also removed and Paper C becomes unusable.
When the user tries again, Origyn should not manufacture V3.
It should tell the truth:
No Usable Evidence.
That distinction — preserving history while allowing the current answer to evolve — became one of the most important design decisions in the project.



The Evidence Graph: making provenance visible

We could have kept all of this as backend metadata.
That would have been easier.
It also would have missed the point.
If provenance matters, the user should be able to inspect it.
So Origyn includes an Evidence Graph that visualises the relationship between documents, claims, and answers.
Instead of giving the researcher an opaque AI response, the graph lets them move backwards:
Answer → Claim → Source
and understand why the answer exists.
We deliberately kept refining this interface because evidence graphs can become unreadable very quickly.
Our first versions were dense enough to qualify as modern art.
Too many nodes, too many lines, and suddenly “traceable provenance” looked more like someone had dropped a bowl of noodles onto the screen.
We eventually moved toward focused, navigable lineage paths: show the part of the graph the researcher is actually trying to inspect, and keep the larger structure available without making it visually overwhelming.
One small bug captured the spirit of frontend development perfectly:
the graph zoomed correctly when we pressed  +  and  - , but the label stubbornly remained at 100%.
The graph had moved on.
The percentage had not.
It was spiritually committed to 100%.



“No retraction found” does not mean “scientifically valid”

This became another important lesson.
Origyn uses scholarly metadata, including Crossref, to identify papers and look for retraction-related updates.
Crossref's REST API exposes bibliographic metadata as well as post-publication updates, and its production services now include Retraction Watch data.
That is extremely useful.
But we had to be precise about what the result means.
If Origyn checks a DOI and finds no known retraction notice, the correct statement is:
No retraction found.
Not:
This paper is valid.
Not:
This research is scientifically correct.
Those are completely different claims.
A registry can tell us what has been reported to it. It cannot certify the truth of the underlying science.
That distinction shaped the UI and the data model. We wanted Origyn to communicate uncertainty instead of laundering uncertainty into a green badge.



Why deletion became a philosophy problem

At first, “Delete source” sounded like one button and one API endpoint.
Then we asked a bad question:
What if that source was already used in an answer?
If we physically erased every trace of it, the historical answer would suddenly point to nothing.
That is terrible provenance.
So deletion became a two-layer concept.
For the active workspace, a deleted source should disappear.
For historical lineage, the system may still need a tombstone saying:
this source existed, it was used here, and it was later deleted.
That lets us preserve the chain without pretending the source is still available.
It was a useful reminder that in provenance systems, “delete” is not always synonymous with “forget.”



The AWS architecture

Origyn is submitted under the Ship It track, and AWS became the actual backbone of the system rather than a service we added at the end for the architecture diagram.
The flow is broadly:
Next.js Frontend
↓
Amazon API Gateway
↓
AWS Lambda
↙ ↓ ↘
S3 DynamoDB Bedrock
↓
Evidence State

AWS Lambda

Lambda powers the serverless backend workflows:
  • document processing
  • claim extraction
  • source-status handling
  • chat generation
  • evidence impact propagation
  • answer regeneration
  • graph generation
  • source deletion
  • source viewing
Breaking the system into focused functions meant we could evolve individual workflows without maintaining a traditional application server.

Amazon API Gateway

API Gateway exposes those workflows to the frontend.
The frontend talks to one API layer while Lambda handles the actual serverless execution behind it.
This sounds simple.
We later discovered that it is only simple when you are modifying the correct API Gateway.
More on that shortly.

Amazon DynamoDB

DynamoDB stores the research state:
  • documents
  • claims
  • answers
  • answer versions
  • evidence statuses
  • provenance relationships
Origyn is less like a conventional CRUD application and more like a set of entities whose states change independently over time.
That made DynamoDB a natural fit.

Amazon S3

S3 stores the original uploaded research documents.
The bucket remains private.
When the researcher chooses View Source, the backend generates a short-lived presigned URL instead of exposing the document publicly.

Amazon Bedrock

Bedrock is the generation layer.
A subtle but important design decision is that Bedrock does not decide what evidence is valid.
Origyn does that first.
The system determines which claims are currently usable, and only then sends the relevant evidence to the model for generation.
The model generates.
The evidence layer governs.

Amazon CloudWatch

CloudWatch became one of our favourite services for a reason we did not expect:
things broke.
From the frontend, several completely different failures looked identical:
 500 Request Failed 
CloudWatch let us move from guessing to seeing the real exception.
That distinction saved us more than once.

AWS Amplify Hosting

For the final web deployment, Origyn uses AWS Amplify Hosting for the Next.js frontend, keeping the public product connected to the same AWS backend used during development.



What fought back

A good hackathon story needs a section where everything works perfectly.
This is not that section.

1. Our Lambda build passed. The ZIP contained no JavaScript.

We were writing the backend in TypeScript.
Our packaging workflow ran a command based on:
tsc --noEmit
The type check passed.
Wonderful.
Except  --noEmit  means exactly what it says.
No JavaScript was emitted.
So we had achieved something technically impressive:
a successful build that confidently produced a deployment package without the compiled application.
Lambda responded with:
Runtime.ImportModuleError
because the handler file simply was not there.
A green checkmark, emotionally supportive and operationally useless.
The fix was to separate type checking from the actual build and make sure our deployment package contained the compiled  dist/handlers/...  files expected by Lambda.

2. Then we fixed the wrong API Gateway

Later, we added new routes for source deletion and source viewing.
The Lambda functions were corrected.
The handlers existed.
Direct invocation worked.
The frontend still failed.
Eventually we discovered that one of our setup scripts had created a second API Gateway.
We had correctly fixed the routes on API B.
The frontend was still talking to API A.
We had two doors, fixed the lock on Door B, and kept trying Door A.
After mapping the real request path end-to-end — frontend URL → API Gateway route → integration → Lambda → logs — the problem became obvious.
It also taught us an AWS lesson we will probably remember longer than any tutorial:
always verify the exact deployed resource, not just the resource name you think you changed.

3. Bedrock access was not “click button, receive AI”

Bedrock itself integrated cleanly once configured, but the initial access path involved region selection, model availability, permissions, and errors that were not always immediately diagnostic.
At different points we had to separate:
  • IAM permissions
  • model access
  • account restrictions
  • regional availability
Once the configuration was correct, Bedrock behaved exactly like we wanted: a managed generation layer inside the AWS stack.
Getting there taught us to debug cloud permissions systematically instead of randomly changing policies until the error disappeared.



The frontend challenge was not making it pretty. It was making state understandable.

Origyn has a surprising number of states:
  • Processing
  • No retraction found
  • Retracted
  • Unable to verify
  • Invalid
  • Deleted
  • Supported
  • Unsupported
  • Current
  • Evidence Changed
  • No Usable Evidence
Putting all of those onto a screen is easy.
Making them understandable is not.
A major part of the frontend work became subtraction.
We removed duplicate actions.
We removed prototype controls.
We kept Add Source where it actually belonged instead of placing it everywhere.
We cleaned up breadcrumbs and workspace chrome.
We simplified the Evidence Graph.
We removed a separate Download action when View Source was enough.
The lesson was simple:
when the underlying system is already conceptually complex, the interface should not compete with it.



What we learned

Provenance is more useful when it can react

A citation at the bottom of an answer is useful.
A lineage that can tell you that the citation has become unreliable — and which part of the answer depended on it — is more useful.

History should not be rewritten

When evidence changes, deleting the old answer would make the system look cleaner.
It would also make it less trustworthy.
Origyn keeps answer versions because the old answer was genuinely produced from the evidence that existed at that time.
Trust is not pretending we were always right.
Sometimes it is remembering exactly when we stopped being right.

AI should be allowed to abstain

 NO_USABLE_EVIDENCE  started as an edge case.
It became one of our favourite features.
If there is no usable evidence left, the system should not be rewarded for sounding confident.

“No retraction found” is a narrow statement

We learned to be careful with status language.
A missing retraction notice is not a scientific endorsement.
That small semantic difference matters in research tooling.

AWS made the prototype behave like a real system

Using Lambda, API Gateway, DynamoDB, S3, Bedrock, CloudWatch, and Amplify forced us to think about deployment, failures, storage, permissions, state transitions, and observable infrastructure.
The project became better because it could not hide behind localhost.



Where Origyn goes next

The current version proves the evidence lifecycle:
source → claim → answer → evidence changes → impact → regeneration
There is much more we would explore next:
  • richer correction and expression-of-concern signals, not only retractions
  • stronger claim-level evidence scoring
  • multi-source contradiction handling
  • better graph exploration for large research libraries
  • exportable provenance reports
  • more scholarly metadata providers
  • monitoring sources for future status changes
  • more granular explanation of exactly why an answer changed
The long-term idea is larger than one research workspace.
We think AI systems need a concept of evidence memory.
Not just:
What did we say before?
But:
Why did we say it?
What evidence supported it?
Is that evidence still usable?
If not, what downstream conclusions should change?



The final idea

Research does not stand still.
Papers are corrected.
Papers are challenged.
Papers are retracted.
Evidence disappears.
Better evidence arrives.
AI-generated answers should not be frozen while the knowledge beneath them changes.
A useful research assistant should remember more than the conversation.
It should remember the origin of a claim.
It should remember which source supported it.
It should remember which answer depended on it.
And when that evidence changes, the system should not quietly carry on as if nothing happened.
That is what we built Origyn to explore.
Origyn remembers the path from paper to claim to answer — and notices when that path stops being trustworthy.
And sometimes the most trustworthy thing an AI system can say is:
“I don't have usable evidence anymore.”
We think that is a feature.



References



Contact:
Abdul Farooqui — +91 9793848072
Parth Malhotra — +91 7009205889
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article