RAG and Prompting Techniques History and Timeline - Chain-of-Thought, ReAct, RAG, and GraphRAG
First Published:
Last Updated:
Questions such as "when was RAG first proposed?", "who introduced chain-of-thought prompting?", and "when did GraphRAG appear?" are asked constantly by AI engineers, researchers, and learners - yet the answers are scattered across separate papers and company blogs, and secondary summaries often cite the wrong date. This article is my attempt at a single, primary-sourced reference. Every row in the timeline links to a primary source: the original arXiv paper (recorded at its v1 submission date) or, when a technique was first introduced by a company, that company's own blog or repository.
This article focuses on the first appearance of named, widely adopted techniques and how the two lineages converge into agentic RAG and context engineering. It is not an implementation tutorial, a benchmark comparison, or an exhaustive survey of every method; those are covered in my dedicated RAG-cluster articles. The history of tool use, function calling, and the MCP and A2A protocols is covered in a separate companion timeline, and model release history is covered in my model timelines.
Companion articles on hidekazu-konishi.com:
- Amazon Bedrock RAG Architecture Guide
- Agentic RAG Architecture on Amazon Bedrock
- GraphRAG Architecture on AWS with Amazon Neptune and Amazon Bedrock
- Amazon Bedrock Knowledge Bases Retrieval Quality Engineering
- Tool Use and Agent Protocol History and Timeline - Function Calling, MCP, and A2A
Background and Method of Creating the RAG and Prompting Techniques Timeline
The reason for creating this timeline is that the "technique" layer of modern AI has evolved extremely quickly, across many research groups and vendors, and the primary facts - who introduced what, and when - are scattered and frequently misdated in secondary writeups. I wanted one page that organizes these facts chronologically, with a primary source for each one.Two lineages run through this history in parallel, and it is worth defining them precisely:
- A prompting or reasoning technique changes how a model is instructed and how it reasons at inference time - for example in-context learning, chain-of-thought, self-consistency, ReAct, and tree of thoughts. Nothing is retrieved from an external corpus; the leverage comes from the structure of the prompt and the reasoning process.
- A retrieval-augmented generation (RAG) technique changes what a model can access at inference time by retrieving external documents and supplying them to the generator - for example dense retrieval, the original RAG architecture, HyDE, Self-RAG, CRAG, GraphRAG, and Contextual Retrieval.
To organize this history, I have taken the following approaches.
- Tracking the history of prompting and RAG techniques and organizing the transition of updates.
- Summarizing the current overall picture as a map of technique families.
- A row records the first appearance of a named technique that became widely cited and/or implemented in major frameworks (for example LangChain, LlamaIndex, DSPy, or Amazon Bedrock Knowledge Bases). Minor variants are omitted.
- Dates for research papers are the arXiv v1 (first version) submission date, not a later revision or a conference publication date. For techniques first introduced by a company - GraphRAG and Anthropic's Contextual Retrieval - the date is the official blog or repository publication date.
- Technique names use each author's own wording. No benchmark scores are transcribed, and each technique is described only within the claims of its primary source.
- Training-time techniques are out of scope. Instruction tuning and RLHF-style alignment methods appear only where they directly underpin a prompting behavior (for example, FLAN's instruction tuning explaining zero-shot instruction following); a dedicated model-training or alignment timeline is a separate subject from this inference-time timeline.
This timeline primarily references the following primary sources.
There may be slight variations between the date a paper was submitted to arXiv, the date a revised version appeared, and the date a technique was formally published at a conference. The dates below use the arXiv v1 submission date for papers.
The content posted here is limited to the milestones considered essential for understanding the history of RAG and prompting techniques.
In other words, please note that the items on this timeline are not all techniques in this area, but are representative milestones that I have picked out.
RAG and Prompting Techniques Historical Timeline (Milestones from November 1, 2019)
Here is the chronological timeline of the major milestones in prompting and RAG techniques, from the retrieval and reasoning precursors of 2019-2021 through the convergence into agentic RAG and context engineering in 2025. Each row links to its primary source - the original arXiv paper or the official announcement.* You can sort the table by clicking on the column name.
| Date | Event |
|---|---|
| 2019-11-01 | kNN-LM shows that a fixed language model can be extended with an explicit datastore at inference time. Nearest Neighbor Language Models (kNN-LM) interpolate a model's next-token distribution with nearest-neighbor lookups over a datastore of cached representations, an early demonstration that non-parametric memory can extend a trained model without retraining - a conceptual precursor to retrieval-augmented generation. Source: Generalization through Memorization: Nearest Neighbor Language Models. |
| 2020-02-10 | REALM introduces retrieval-augmented language model pre-training. REALM augments a language model with a learned knowledge retriever that is trained jointly with the model, so it can retrieve and attend over documents from a large corpus during both pre-training and inference. Source: REALM: Retrieval-Augmented Language Model Pre-Training. |
| 2020-04-10 | Dense Passage Retrieval (DPR) establishes learned dense embeddings for open-domain retrieval. DPR trains a dual-encoder to embed questions and passages into a shared vector space, showing that learned dense retrieval can be highly effective for open-domain question answering - the retrieval component that many later RAG systems build on. Source: Dense Passage Retrieval for Open-Domain Question Answering. |
| 2020-05-22 | Lewis et al. introduce Retrieval-Augmented Generation (RAG) and give the pattern its name. RAG combines a pre-trained sequence-to-sequence generator (parametric memory) with a dense vector index of Wikipedia accessed by a retriever (non-parametric memory), fine-tuned end-to-end for knowledge-intensive tasks. This paper is the origin of the term "RAG". Source: Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. |
| 2020-05-28 | The GPT-3 paper demonstrates few-shot, in-context learning from the prompt alone. "Language Models are Few-Shot Learners" shows that a large model can perform new tasks when given a few examples in its prompt, with no gradient updates - establishing in-context learning and few-shot prompting, the foundation of what the community later called prompt engineering. Source: Language Models are Few-Shot Learners. |
| 2020-07-02 | Fusion-in-Decoder (FiD) scales retrieval-augmented generative question answering. FiD retrieves many passages, encodes each independently, and fuses them in the decoder, showing that a generative reader benefits from processing large numbers of retrieved passages. Source: Leveraging Passage Retrieval with Generative Models for Open Domain Question Answering. |
| 2021-07-28 | The "Pre-train, Prompt, and Predict" survey systematizes prompting as a paradigm. This survey organizes the emerging prompt-based learning literature into a common framework and terminology, marking the point at which prompting was treated as a distinct methodology rather than an ad-hoc trick. Source: Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing. |
| 2021-09-03 | FLAN shows that instruction tuning improves zero-shot prompting. "Finetuned Language Models Are Zero-Shot Learners" introduces instruction tuning - fine-tuning on many tasks phrased as natural-language instructions - which makes a model follow prompts for tasks it was not explicitly trained on, strengthening the zero-shot prompting that later techniques rely on. Source: Finetuned Language Models Are Zero-Shot Learners. |
| 2021-11-30 | The Scratchpads paper shows that emitting intermediate steps improves multi-step computation. "Show Your Work" has a model write intermediate results to a scratchpad before producing the final answer, an immediate precursor to chain-of-thought prompting. Source: Show Your Work: Scratchpads for Intermediate Computation with Language Models. |
| 2021-12-08 | RETRO retrieves from trillions of tokens during language modeling. RETRO (Retrieval-Enhanced Transformer) augments a transformer with retrieval from a database of trillions of tokens via chunked cross-attention, demonstrating retrieval augmentation at pre-training scale. Source: Improving language models by retrieving from trillions of tokens. |
| 2022-01-28 | Wei et al. introduce chain-of-thought (CoT) prompting. Chain-of-thought prompting elicits multi-step reasoning by providing exemplars that include intermediate reasoning steps, improving performance on arithmetic, commonsense, and symbolic reasoning tasks. Source: Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. |
| 2022-03-21 | Self-Consistency improves chain-of-thought by sampling and voting. Instead of following a single greedy reasoning path, self-consistency samples multiple chains of thought and selects the most consistent final answer by majority vote. Source: Self-Consistency Improves Chain of Thought Reasoning in Language Models. |
| 2022-05-21 | Least-to-Most prompting decomposes a problem into ordered subproblems. Least-to-most prompting first breaks a complex problem into simpler subproblems and then solves them in sequence, each using the answers to earlier ones - an explicit decomposition strategy. Source: Least-to-Most Prompting Enables Complex Reasoning in Large Language Models. |
| 2022-05-24 | "Let's think step by step" enables zero-shot chain-of-thought reasoning. "Large Language Models are Zero-Shot Reasoners" shows that simply appending the phrase "Let's think step by step" elicits multi-step reasoning without any worked exemplars - zero-shot CoT. Source: Large Language Models are Zero-Shot Reasoners. |
| 2022-10-06 | ReAct interleaves reasoning and acting in language models. ReAct (Reason + Act) prompts a model to alternate reasoning traces with actions such as calling an external search API, coupling chain-of-thought reasoning with tool-augmented action - a template for later agentic systems. The broader history of tool use and function-calling APIs is covered in a companion timeline. Source: ReAct: Synergizing Reasoning and Acting in Language Models. |
| 2022-10-07 | Automatic Chain-of-Thought (Auto-CoT) removes the need for hand-written reasoning exemplars. Auto-CoT clusters questions and uses zero-shot CoT to automatically construct demonstrations, reducing the manual effort of designing chain-of-thought prompts. Source: Automatic Chain of Thought Prompting in Large Language Models. |
| 2022-11-18 | Program-Aided Language models (PAL) offload computation to a program interpreter. PAL has the model generate intermediate reasoning as executable program statements and delegates the actual calculation to a Python interpreter rather than to the model itself. Source: PAL: Program-aided Language Models. |
| 2022-12-20 | HyDE performs zero-shot dense retrieval via hypothetical documents. HyDE (Hypothetical Document Embeddings) has the model first generate a hypothetical answer document, then embeds that document to retrieve real passages - a query-transformation technique that improves retrieval without relevance labels. Source: Precise Zero-Shot Dense Retrieval without Relevance Labels. |
| 2023-02-09 | Toolformer shows that a model can teach itself to call APIs. Toolformer is trained in a self-supervised way to decide which API to call, when to call it, and with what arguments, from only a handful of demonstrations. It is included here as a technique milestone; the productized tool-use and function-calling history is covered in a companion timeline. Source: Toolformer: Language Models Can Teach Themselves to Use Tools. |
| 2023-03-20 | Reflexion adds verbal self-reflection to language agents. Reflexion has an agent reflect in natural language on feedback from previous attempts and store those reflections in memory to improve subsequent tries, without updating model weights. Source: Reflexion: Language Agents with Verbal Reinforcement Learning. |
| 2023-05-17 | Tree of Thoughts generalizes chain-of-thought into a search over reasoning paths. Tree of Thoughts (ToT) explores multiple reasoning branches ("thoughts") with lookahead and backtracking, framing problem solving as deliberate search rather than a single left-to-right chain. Source: Tree of Thoughts: Deliberate Problem Solving with Large Language Models. |
| 2023-08-18 | Graph of Thoughts models reasoning as an arbitrary graph. Graph of Thoughts (GoT) extends tree-structured reasoning to a graph, allowing thoughts to be aggregated and combined rather than only branched. Source: Graph of Thoughts: Solving Elaborate Problems with Large Language Models. |
| 2023-09-20 | Chain-of-Verification (CoVe) reduces hallucination through structured self-checking. CoVe has the model draft an answer, generate verification questions, answer them independently, and then revise the response - a self-critique loop aimed at improving factual accuracy. Source: Chain-of-Verification Reduces Hallucination in Large Language Models. |
| 2023-10-05 | DSPy reframes prompting as programming with compiled pipelines. DSPy expresses LLM pipelines as declarative modules and "compiles" them - optimizing the prompts and few-shot examples automatically - shifting effort from hand-tuned prompt wording to program structure. Source: DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines. |
| 2023-10-17 | Self-RAG lets a model decide when to retrieve and critique what it retrieves. Self-RAG trains a model to adaptively retrieve passages on demand and to generate special reflection tokens that critique both the retrieved evidence and its own output. Source: Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection. |
| 2023-12-18 | A widely cited survey organizes RAG into Naive, Advanced, and Modular paradigms. "Retrieval-Augmented Generation for Large Language Models: A Survey" consolidates the field and popularizes the Naive RAG, Advanced RAG, and Modular RAG framing that later work frequently reuses. Source: Retrieval-Augmented Generation for Large Language Models: A Survey. |
| 2024-01-29 | Corrective RAG (CRAG) adds a retrieval evaluator to make RAG robust to poor retrieval. CRAG grades retrieved documents and triggers corrective actions - such as web search or knowledge refinement - when the retrieval is judged incorrect or ambiguous. Source: Corrective Retrieval Augmented Generation. |
| 2024-01-31 | RAG-Fusion combines multi-query generation with reciprocal rank fusion. RAG-Fusion generates several related queries from the original question, retrieves for each, and fuses the results with reciprocal rank fusion to broaden coverage before generation. Source: RAG-Fusion: a New Take on Retrieval-Augmented Generation. |
| 2024-01-31 | RAPTOR builds a hierarchical summary tree for retrieval at multiple levels of abstraction. RAPTOR recursively embeds, clusters, and summarizes text chunks into a tree, so retrieval can draw on both fine-grained details and higher-level summaries of long documents; the technique was subsequently adopted by major RAG frameworks. Source: RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval. |
| 2024-02-13 | Microsoft Research introduces GraphRAG. In a research blog post, Microsoft presented GraphRAG, a graph-based approach that builds a knowledge graph from source documents and uses community summaries to answer global, whole-corpus questions that naive RAG handles poorly. Source: GraphRAG: Unlocking LLM discovery on narrative private data. |
| 2024-04-24 | The GraphRAG paper details the local-to-global graph approach. "From Local to Global: A Graph RAG Approach to Query-Focused Summarization" describes constructing an entity knowledge graph and generating community summaries to support query-focused summarization over an entire corpus. Source: From Local to Global: A Graph RAG Approach to Query-Focused Summarization. |
| 2024-07-02 | Microsoft open-sources GraphRAG on GitHub. Microsoft Research released the GraphRAG library publicly, making the graph-construction and query pipeline available as open source alongside a solution accelerator. Source: GraphRAG: New tool for complex data discovery now on GitHub. |
| 2024-09-19 | Anthropic introduces Contextual Retrieval. Contextual Retrieval prepends chunk-specific explanatory context to each chunk before embedding and indexing, combining contextual embeddings with a contextual BM25 index to reduce failed retrievals in RAG systems. Source: Introducing Contextual Retrieval. |
| 2024-10-08 | LightRAG combines graph structure with lightweight dual-level retrieval. LightRAG incorporates graph structures into indexing and a dual-level retrieval process to handle relational queries efficiently, positioning itself as a simpler, faster graph-augmented RAG. Source: LightRAG: Simple and Fast Retrieval-Augmented Generation. |
| 2025-01-15 | A survey defines and consolidates Agentic RAG. "Agentic Retrieval-Augmented Generation: A Survey on Agentic RAG" describes embedding autonomous agents - using planning, reflection, and tool use - into the RAG pipeline so that retrieval strategy is decided dynamically rather than fixed in advance. Source: Agentic Retrieval-Augmented Generation: A Survey on Agentic RAG. |
| 2025-07-17 | A survey formalizes context engineering as a discipline. "A Survey of Context Engineering for Large Language Models" reframes the context as a dynamically assembled set of components - spanning retrieval, memory, and tool results - rather than a single static prompt string, unifying RAG, memory, and tool-integrated reasoning under one framework. Source: A Survey of Context Engineering for Large Language Models. |
| 2025-10-06 | Agentic Context Engineering treats the context itself as something the system evolves. This work frames contexts as evolving "playbooks" that an agent iteratively updates from execution feedback, connecting prompting, retrieval, and memory into a self-improving loop. Source: Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models. |
There may be slight variations between a paper's arXiv v1 submission date, the date of a later revision, and the date of formal conference publication. The dates above use the arXiv v1 submission date for papers, and the official publication date for company blogs and repositories.
Current Overview of RAG and Prompting Techniques
Having followed the chronology, this section summarizes the current overall picture as two lineages - prompting and reasoning techniques, and retrieval-augmented generation - and how they converge into agentic RAG and context engineering. The goal here is a map, not a tutorial; implementation-level coverage lives in the dedicated articles linked at the end.Prompting and Reasoning Techniques
Prompting techniques share a common idea: hold the model weights fixed and change the input and the reasoning process to get better results. They cluster into a few families:- In-context learning: few-shot and zero-shot prompting, established by the GPT-3 paper. The model learns the task from examples or instructions in the prompt, with no gradient updates.
- Chain-of-thought family: chain-of-thought, zero-shot CoT ("Let's think step by step"), self-consistency (sample many chains and vote), and Auto-CoT (build the exemplars automatically). These make intermediate reasoning explicit.
- Decomposition: least-to-most prompting breaks a hard problem into ordered subproblems.
- Reasoning topologies: tree of thoughts and graph of thoughts generalize a single reasoning chain into search over branching or graph-structured thoughts.
- Self-critique: reflexion (verbal self-reflection with memory) and chain-of-verification (draft, verify, revise) have the model check and improve its own output.
- Program-aided and tool-augmented: PAL offloads calculation to a program interpreter, and ReAct interleaves reasoning with actions such as search. (The productized tool-use and protocol story is delegated to the companion tool-use timeline.)
- Pipeline optimization: DSPy turns prompting into programming, compiling and optimizing prompts and few-shot examples instead of hand-tuning wording.
Retrieval-Augmented Generation
RAG changes what the model can read. The widely used Naive - Advanced - Modular framing from the 2023 RAG survey, extended with the graph-based approaches that followed, gives a useful map:| Paradigm | Core idea and representative techniques |
|---|---|
| Naive RAG | The basic retrieve-then-read pipeline: embed and index chunks, retrieve by similarity, and pass the results to the generator. Built on dense retrieval (DPR) and the original RAG architecture (Lewis et al.). |
| Advanced RAG | Pre- and post-retrieval optimization: query transformation (HyDE), reranking, and chunk enrichment such as Anthropic's Contextual Retrieval, to raise retrieval quality. |
| Modular RAG | Adaptive and corrective modules: Self-RAG (retrieve on demand and self-critique), CRAG (evaluate retrieval and correct it), and RAG-Fusion (multi-query generation with rank fusion). |
| Graph RAG | Structure retrieval around a knowledge graph: GraphRAG (entity graph plus community summaries for whole-corpus questions) and LightRAG (lightweight graph-augmented retrieval). |
How the Two Lineages Converge
By 2025 the prompting and RAG lineages meet. Agentic RAG applies reasoning techniques - planning, reflection, and ReAct-style action - to control retrieval itself: rather than a fixed retrieve-then-generate pipeline, an agent decides whether to retrieve, what to retrieve, and how to use the results. Context engineering is the broader discipline that contains both lineages: it treats the model's context as a dynamically assembled payload - the prompt plus retrieved documents, memory, and tool outputs - and studies how to select and manage that whole payload. In this framing, individual prompting and RAG techniques become components of a context-engineering system.
Where to Go Deeper
This timeline is a reference map; the deep dives live in dedicated articles on this site. For building and operating these techniques on AWS, see my Amazon Bedrock RAG Architecture Guide, Agentic RAG Architecture on Amazon Bedrock, GraphRAG Architecture on AWS with Amazon Neptune and Amazon Bedrock, and Amazon Bedrock Knowledge Bases Retrieval Quality Engineering. For the operational layers around these techniques, see Semantic Caching for LLM Applications on AWS and Anthropic Claude API Prompt Caching and Token Efficiency. For the tool-use and protocol thread, see the Tool Use and Agent Protocol History and Timeline.Frequently Asked Questions about RAG and Prompting Techniques History
When was RAG first proposed?
Retrieval-Augmented Generation was introduced by Lewis et al. in a paper first submitted to arXiv on 2020-05-22, "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks", which also gave the pattern its name. It combined a pre-trained sequence-to-sequence generator with a dense vector index of Wikipedia accessed by a retriever. Earlier retrieval-augmentation work such as REALM (2020-02-10) and DPR (2020-04-10) preceded it.Who introduced chain-of-thought prompting?
Chain-of-thought (CoT) prompting was introduced by Wei et al. in "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models", first submitted to arXiv on 2022-01-28. It elicits multi-step reasoning by including intermediate reasoning steps in the prompt's exemplars. A zero-shot variant using the phrase "Let's think step by step" followed on 2022-05-24.What is the difference between RAG and Agentic RAG?
Classic RAG follows a mostly fixed retrieve-then-generate pipeline. Agentic RAG embeds an autonomous agent - using planning, reflection, and tool use - into that pipeline, so whether to retrieve, what to retrieve, and how to use the results are decided dynamically. The agentic framing was consolidated in a survey submitted on 2025-01-15. Implementation details are covered in my dedicated Agentic RAG article.When did GraphRAG appear?
Microsoft Research introduced GraphRAG in a blog post on 2024-02-13, published the accompanying paper "From Local to Global: A Graph RAG Approach to Query-Focused Summarization" on arXiv on 2024-04-24, and open-sourced the GraphRAG library on GitHub on 2024-07-02. GraphRAG builds a knowledge graph from source documents and uses community summaries to answer whole-corpus questions.What is the difference between prompt engineering and context engineering?
Prompt engineering focuses on how a single instruction is phrased. Context engineering, formalized in a survey submitted on 2025-07-17, treats the model's context as a dynamically assembled set of components - the prompt plus retrieved documents, memory, and tool results - and studies how to select and manage that whole payload. In this framing, RAG and prompting techniques are components of context engineering.What are chain-of-thought, ReAct, and tree of thoughts?
They are prompting and reasoning techniques. Chain-of-thought (2022-01-28) elicits step-by-step reasoning. ReAct (2022-10-06) interleaves reasoning with actions such as calling a search tool. Tree of thoughts (2023-05-17) generalizes a single reasoning chain into a search over multiple branching reasoning paths with lookahead and backtracking.Do the dates in this timeline use the arXiv submission date?
Yes. For research papers, each date is the arXiv v1 (first version) submission date, not the date of a later revision or a conference publication. For techniques first introduced by a company - such as GraphRAG and Anthropic's Contextual Retrieval - the date is the official blog or repository publication date.Summary
In this article, I created a historical timeline of RAG and prompting techniques and summarized the current overall picture as two converging lineages.The timeline shows three phases: a 2019-2021 foundation phase in which dense retrieval (DPR), the original RAG architecture (Lewis et al.), and in-context learning (GPT-3) established that a model's knowledge and reasoning could be extended from outside; a 2022-2023 phase in which reasoning techniques (chain-of-thought, self-consistency, ReAct, tree of thoughts) and modular RAG (Self-RAG, CRAG) matured; and a 2024-2025 phase in which graph-based RAG (GraphRAG, LightRAG) and chunk enrichment (Contextual Retrieval) arrived, and the two lineages converged into agentic RAG and context engineering. The result is a two-lineage model - prompting for how a model reasons, RAG for what it can read - that now structures how LLM applications are built.
By organizing these milestones in one place with a primary source for each, I hope this article serves as a reference that AI search agents, developers, and researchers can consult in a single fetch.
This timeline will be updated as RAG and prompting techniques continue to evolve.
In addition, there are related history-and-timeline articles on this site, so please have a look if you are interested.
Tool Use and Agent Protocol History and Timeline - Function Calling, MCP, and A2A
Anthropic Claude Model Release Timeline - Model Family Tree, Capability Evolution, and Platform Availability
OpenAI GPT Model Release Timeline
Amazon Bedrock RAG Architecture Guide
References:
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (Lewis et al.)
Language Models are Few-Shot Learners (GPT-3)
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
ReAct: Synergizing Reasoning and Acting in Language Models
From Local to Global: A Graph RAG Approach to Query-Focused Summarization
Anthropic: Introducing Contextual Retrieval
A Survey of Context Engineering for Large Language Models
Amazon Bedrock RAG Architecture Guide
Agentic RAG Architecture on Amazon Bedrock
Tool Use and Agent Protocol History and Timeline - Function Calling, MCP, and A2A
References:
Tech Blog with curated related content
Written by Hidekazu Konishi