
The Paper Got Retracted. Our AI Answer Didn't Get the Memo. — Building Origyn on AWS
What happens when an AI answer outlives the evidence that made it trustworthy? Origyn tracks evidence from source to claim to answer, then follows the consequences when that evidence changes
Evidence Has a Lifecycle. AI Answers Should Too.
How we built Origyn on AWS to track the path from research paper to claim to answer — and keep that path honest 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
The answer was correct yesterday. What about today?
There is a strange assumption hidden inside many AI research tools.
We treat the answer as dynamic while it is being generated, but static once it exists.
That makes sense for ordinary chat.
It makes much less sense for research.
Scientific knowledge has a lifecycle. A paper may be corrected, retracted, challenged, superseded, or removed from a researcher's working set. The evidence can change after an answer has already been generated.
The answer, however, often has no lifecycle at all.
It remains a polished paragraph in a chat history.
That mismatch is the reason we built Origyn.
Origyn is an evidence-memory layer for AI-assisted research. Its purpose is not simply to store papers or generate answers from them. It maintains the connection between the source material, the claims derived from it, and the answers produced from those claims.
The model is intentionally simple:
Document → Claim → AnswerSimple models are useful because they make difficult consequences visible.
If the document changes status, we know which claims are affected.
If the claims are affected, we know which answers need attention.
That is the core idea behind Origyn.
Why we believed the problem was worth solving
Before writing code, we wanted to know whether evidence drift was a real problem or just an elegant architecture looking for a use case.
The literature gave us an uncomfortable answer.
One large study examined 7,813 retracted papers and 169,434 citations across biomedical literature. Among 13,252 citation contexts published after retraction, only 722 — 5.4% — acknowledged the retraction.
Another analysis focused on retracted systematic reviews. It found 954 citations to 128 retracted reviews, and 580 of those citations — 60.8% — occurred after the review had already been retracted.
The lesson is not merely that retractions happen.
It is that the consequences of retractions do not propagate automatically.
A source changes state, while the things that depend on it continue moving through the world.
Now add generative AI.
A language model can compress many papers into one fluent answer. That is useful, but it also makes provenance easier to overlook because the final text feels self-contained.
Research has also documented problems with AI-generated references. A 2023 Scientific Reports study generated literature-review-style text using GPT-3.5 and GPT-4. In that experiment, 55% of GPT-3.5 references and 18% of GPT-4 references were fabricated.
We are not using that result to argue that modern LLMs cannot support research. They clearly can.
We are using it to make a narrower point:
fluency is not evidence management.
Systems such as Crossref provide rich scholarly metadata and now expose Retraction Watch data through the REST API. That gives developers powerful signals about source status.
But a signal that says “this paper was retracted” is only the beginning of the workflow we cared about.
We wanted to know:
what depends on it?
We nearly built something much more ordinary
Like many hackathon projects, Origyn began with a list of AI ideas.
Agents.
Summarisers.
Research copilots.
PDF question-answering.
Each idea was useful.
Each also felt like something we had seen before.
Eventually we realised we were optimising the wrong question.
We were asking:
What can we make the model do?
Instead, we tried:
What part of the system around the model is still fragile?
That led us away from generation and toward memory, provenance, and change.
The model became one component.
The interesting system became everything around it.
What makes Origyn different from “chat with PDFs”
A conventional research chat flow looks roughly like:
Documents ↓Retrieval ↓LLM ↓AnswerOrigyn adds a persistent semantic layer:
Documents ↓Claims ↓AnswersThat difference matters because claims are where source-level change becomes answer-level impact.
Suppose a paper supports two extracted claims.
If the paper becomes unusable, those claims should no longer silently participate in future generation.
If an answer used those claims, the answer should be marked as affected.
That gives us a state transition rather than a vague warning.
For example:
ACTIVE DOCUMENT ↓SUPPORTED CLAIM ↓CURRENT ANSWERcan become:
RETRACTED DOCUMENT ↓UNSUPPORTED CLAIM ↓EVIDENCE_CHANGED ANSWERNow the researcher has something actionable.
They can regenerate.
Regeneration is versioning, not replacement
One of our early design choices was to preserve previous answers.
Why?
Because an answer can be historically valid as an output of the evidence that existed at the time, while no longer being the answer we would generate now.
That means regeneration should not behave like editing the old message.
It should create lineage.
V1 → V2 → V3Each version reflects a different evidence state.
This turned out to be useful for debugging too.
When something changed unexpectedly, we could ask not only “what is the current answer?” but “what evidence transition produced this version?”
The system became easier to reason about because history remained visible.
And sometimes regeneration should fail
There is an awkward temptation when building AI products:
always return something.
Users ask a question, so the interface should show an answer.
We decided that was the wrong contract for an evidence-aware product.
Imagine an answer depended on one paper.
That paper is retracted.
There are no other usable sources.
The user asks Origyn to regenerate.
What should happen?
Not this:
Here is another confident answer based on vibes.
Instead, Origyn returns:
NO_USABLE_EVIDENCE
We originally treated this as an edge state.
It became one of the clearest expressions of the product.
An evidence-aware system needs permission to abstain.
Source status is more subtle than green, yellow, red
A surprisingly difficult part of the project was naming things correctly.
If Crossref returns no retraction update for a DOI, what do we display?
It is tempting to say:
Valid
But that overclaims.
Crossref can tell us about metadata and registered updates. Retraction Watch data adds a valuable additional source of retraction information.
Neither turns a metadata lookup into peer review.
So Origyn distinguishes:
No retraction found
from:
Scientifically valid
The first is something the system can reasonably report.
The second is not.
Likewise, papers without DOI metadata created another edge case. A local document should not become useless merely because it lacks a DOI.
So Origyn separates “we could not verify a retraction through this metadata path” from “this document cannot participate in the workspace.”
Those semantics look small in the code.
They are large in the product.
Deletion forced us to choose between usability and provenance
A researcher should be able to delete a source.
Easy requirement.
Until that source has claims.
Or answers.
Or historical graph edges.
If we hard-delete every record, old answers become impossible to explain.
If we never delete anything, the library ignores the user's intent.
So we used a provenance-aware model.
For the active library, a deleted source disappears.
For historical lineage, a DELETED tombstone can remain where needed so an old answer still has an explainable origin.
This also allowed us to propagate deletion similarly to invalidation while preserving the reason:
Document status = DELETEDis not the same thing as:
Document status = INVALIDThat difference matters when the user later inspects history.
Building the Evidence Graph
The graph is where the data model becomes visible.
We render three conceptual layers:
Documents → Claims → Answers
The first version tried to show too much.
Technically impressive.
Practically unreadable.
When every node insists on being important at once, the user stops understanding the graph and starts appreciating line-rendering performance.
We moved toward focused lineage exploration: select an answer or connected path and prioritise the relationships that explain it.
Even the zoom control taught us a small lesson.
The visual camera zoom worked.
The percentage display stayed at
100% .It was a perfect example of a UI being technically functional and semantically wrong.
So we connected the displayed value to the actual camera state instead of to a hardcoded label.
Not our most academically significant contribution.
Possibly our most relatable one.
Shipping Origyn on AWS
We entered the Ship It track, so AWS is not only where the application lives. The services form the actual execution path of the product.
Our architecture can be simplified to:
Next.js ↓Amazon API Gateway ↓AWS Lambda ↓ ┌───────────────┬────────────────┐Amazon S3 Amazon DynamoDB Amazon Bedrockwith Amazon CloudWatch helping us observe and debug the system, and AWS Amplify Hosting serving the final frontend deployment.
AWS Lambda: the workflow engine
Lambda runs the backend operations as focused serverless handlers.
These include:
- document ingestion
- scholarly-status checks
- claim extraction
- answer generation
- document impact calculation
- invalidation
- deletion
- answer regeneration
- graph construction
- presigned source viewing
For a small team, this architecture was fast to evolve.
We could add a capability without standing up another server or maintaining long-running infrastructure.
Amazon API Gateway: one front door to the backend
API Gateway connects the frontend to those Lambda workflows.
The final architecture gives the web application a consistent HTTP API while keeping compute serverless.
We also learned that “one front door” is an architectural goal, not something AWS automatically enforces for you.
At one point, a deployment script accidentally created a second API Gateway.
We deployed two new routes successfully.
Unfortunately, we deployed them to the wrong API.
The frontend continued calling the original gateway.
Everything worked.
Just not together.
That debugging session permanently improved our habit of verifying actual resource IDs and route-to-integration mappings.
Amazon DynamoDB: storing evidence state
DynamoDB stores Origyn's documents, claims, answers, statuses, and lineage metadata.
The interesting part for us was not simply fast key-value storage.
It was that Origyn's data is highly stateful.
A document can change status independently.
A claim can become unsupported.
An answer can move from current to evidence-changed.
A new answer version can supersede an old one without deleting it.
DynamoDB let us represent those transitions without operating database infrastructure ourselves.
Amazon S3: keeping the source of truth
Uploaded source files live in S3.
We did not want to make research files public just so the UI could open them.
Instead, Origyn exposes a backend endpoint that verifies the document and generates a short-lived presigned URL.
The user gets a simple View Source action.
The bucket stays private.
It is one of those AWS patterns that makes the correct security model simpler than the insecure shortcut.
Amazon Bedrock: generation after evidence selection
Bedrock generates the final natural-language answer.
But our architecture intentionally puts evidence selection before model invocation.
Origyn determines what evidence is usable.
Then it asks Bedrock to generate from that evidence.
This separation matters to us.
The model is excellent at language generation.
It should not be asked to invent our evidence-governance rules while generating the answer.
Amazon CloudWatch: when “500” is not enough information
The frontend has a limited vocabulary for backend disasters.
For a while, that vocabulary was:
Request failed: 500
CloudWatch gave us the rest of the sentence.
It exposed real Lambda errors, invocation logs, and runtime failures so we could debug the deployed system rather than infer everything from the browser.
This became critical during our most memorable deployment failure.
What broke, and what it taught us
The compiled backend that was not compiled
Our backend was TypeScript.
The packaging flow ran:
tsc --noEmitThe code passed type checking.
Then we zipped the backend.
Then Lambda complained that it could not find the handler.
Why?
Because
--noEmit means “do not emit JavaScript.”Our deployment artifact successfully contained a TypeScript project that had been verified to compile, while containing none of the compiled JavaScript Lambda expected to execute.
We changed the build process to actually produce the
dist output before packaging.The important lesson was larger:
validate the artifact, not just the source.
A passing build command does not prove the deployed ZIP contains what production needs.
The handler fix that still did not fix anything
After that, we corrected the Lambda handler path.
Still broken.
So we stopped guessing.
We checked:
- deployed Lambda configuration
- ZIP contents
- direct Lambda invocation
- CloudWatch logs
- API Gateway routes
- integration IDs
- Lambda invoke permissions
- actual live API calls
That end-to-end trace exposed the duplicate API Gateway.
It was one of the best debugging lessons of the hackathon because the failure sat between individually correct components.
Distributed systems have a sense of humour.
Bedrock made permissions part of product development
Our early Bedrock setup involved several rounds of access troubleshooting.
Model availability, region, account configuration, and IAM can all influence whether inference succeeds.
Once the access path was correct, the actual integration was clean.
But the process forced us to understand permissions rather than treating AWS as a black box.
That turned out to be valuable later with S3, API Gateway, and Lambda as well.
The part we did not want to compromise: UX
A technically correct provenance system can still be unusable.
Origyn has states that make sense to the backend:
ACTIVERETRACTEDUNKNOWNINVALIDDELETEDSUPPORTEDUNSUPPORTEDCURRENTEVIDENCE_CHANGEDHumans should not have to mentally execute the state machine to use the product.
So we kept simplifying the workspace.
We removed duplicate controls.
We reduced prototype-only UI.
We made source actions contextual.
We surfaced the reason an answer had changed.
We kept deleted documents out of the active library while preserving historical provenance.
We changed chat typography so an evidence-grounded answer was readable rather than a raw wall of model text.
We learned that the more sophisticated the backend becomes, the more disciplined the frontend has to be.
Complexity should exist in the system because the problem requires it.
It should not leak into every interaction.
What Origyn is really trying to remember
Calling Origyn a “memory layer” can sound like another way of saying chat history.
That is not what we mean.
Conversation memory asks:
What did the user and assistant say before?
Evidence memory asks:
What source did this conclusion come from?
Which claims were extracted from it?
Which answer used those claims?
Has the source changed state since then?
Does the answer still deserve to be treated as current?
That is the memory we care about.
The final answer is only one node in a longer chain.
What we learned
1. Trust is a systems problem
No individual component can make an AI research workflow trustworthy.
Not the LLM.
Not the citation.
Not the metadata provider.
Trust comes from how the parts are connected and how the system behaves when one part changes.
2. Uncertainty should survive the UI
If a registry lookup cannot verify something, the UI should not convert that uncertainty into a reassuring green status just because green feels nicer.
Language matters.
3. Provenance becomes valuable when something goes wrong
When everything is valid, provenance can feel like extra metadata.
When evidence changes, provenance becomes the map you need to understand the blast radius.
4. Serverless is fast, but deployment state is real architecture
Lambda and API Gateway helped us move quickly.
They also taught us that the deployed resource graph deserves the same attention as the source-code graph.
5. “No answer” can be a successful outcome
If Origyn has no usable evidence, saying so is not a failure of the AI feature.
It is the evidence system doing its job.
What we would build next
Origyn today focuses on a strong core lifecycle:
Document ↓Claim ↓Answer ↓Evidence changes ↓Impact ↓RegenerationThe natural next steps include:
- tracking corrections and expressions of concern more deeply
- scheduled monitoring of existing sources for status changes
- richer multi-document contradiction detection
- claim confidence and evidence-quality signals
- better support for very large evidence graphs
- provenance export for research reports
- additional scholarly metadata sources
- clearer “what changed between answer versions?” explanations
We also want the evidence layer to become increasingly independent of any one generation model.
That is an important part of the idea.
Models will change.
Evidence provenance should survive them.
Closing
A lot of AI products are trying to make models remember more.
More conversation.
More user preferences.
More files.
We became interested in a different kind of memory.
What if the system remembered the reason behind the answer?
Research knowledge changes.
If an answer depends on evidence, then evidence change is not a footnote.
It is an event in the answer's lifecycle.
Origyn is our attempt to make that lifecycle explicit.
From:
Document → Claim → Answer
and, when necessary, all the way back again.
Because the question is not only:
Can AI answer this?
For research, another question matters just as much:
Do we still have the evidence to stand behind that answer?
References
Contact:
Parth Malhotra — +91 7009205889
Abdul Farooqui — +91 9793848072
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article