What Prompt and Instruction Patterns Govern SEO Agent Behavior?

Most SEO prompt guides are solving the wrong problem. They optimize the wording of individual instructions while leaving the architectural decisions that actually determine agent reliability to chance. The result is agents that sound competent in demos and fail in production, not because the prompts are poorly written, but because the system design assigns responsibilities to prompts that belong elsewhere, and because the most high-leverage instruction patterns, negative constraints, self-consistency decoding, prompt position management, are almost entirely absent from the practitioner conversation.

We've read through the major SEO prompt libraries and the underlying research that should be informing them. The gap is structural, not cosmetic.

What Is a Prompt Pattern in the Context of an SEO Agent?

A prompt pattern is a reusable structural convention that governs how instructions are formatted and sequenced to reliably elicit SEO-relevant outputs from an LLM agent. A single prompt asking an agent to "write a meta description" is a prompt. A pattern specifies the role the agent plays, the task scope, the context it needs, the constraints it must respect, the output format it must produce, and the quality check it should apply before returning anything, and it applies consistently across every meta description the agent will ever generate.

The distinction matters because SEO work is context-dependent at every level. Without a pattern, the underlying Large Language Model defaults to generic assumptions about business type, geography, audience, and keyword intent. A pattern closes that ambiguity before the agent starts reasoning, not after it returns something wrong.

The strongest SEO prompt patterns combine four to six structural elements. Role and persona come first: who is the agent acting as. Task scope follows: exactly what it is being asked to produce. Then constraints, both positive and negative. Then context, the specific metric, time range, page set, or entity list relevant to this task. Then output format, whether JSON, markdown, a numbered list, or a structured table. For multi-step workflows, a quality-check directive closes the pattern, asking the agent to verify coverage, accuracy, or format compliance before output.

A pattern governs the instruction architecture across an entire workflow. That is what separates it from a clever one-liner.

What Does the System Prompt Control in an SEO Agent?

The system prompt is where an SEO agent's strategy becomes policy, controlling persona, domain scope, prohibited behaviors, tool-use sequencing, output format defaults, and the decision logic the agent applies to every task it receives. Every instruction placed there applies before any task-level input is processed, which means it functions as the agent's operating constitution, not a suggestion it can weigh against user requests.

The element most practitioners underuse is decision logic. Instead of writing a system prompt that says "you are an SEO expert," a well-designed system prompt encodes the ranking framework the agent applies: check memory before calling live APIs, classify search intent before suggesting content structure, measure before recommending, never repeat a recommendation already logged in the session.

The research on transformer attention mechanisms is relevant here. Instructions placed near the top of the system prompt receive higher attention weight than those buried later in a long instruction block. This is not a stylistic preference. The "Attention Is All You Need" architecture distributes attention across token positions, and position-sensitive weighting means a critical constraint placed past the 2,000-word mark in a long system prompt is functionally less binding than the same constraint placed in the first 500 words. Global prohibitions, brand voice rules, and output schema requirements go at the top of the system prompt. They do not go in the task prompt, and they do not go at the bottom.

Technical SEO constraints, such as title tag length limits, H1 rules, and internal linking requirements, belong in the system prompt when they apply universally. Task-specific constraints, such as "avoid naming competitors in this particular content brief," belong in the task prompt.

How Do Chain-of-Thought Prompts Compare to Zero-Shot Instructions for SEO Tasks?

Zero-shot is the right default for most production SEO tasks. That runs counter to what a lot of the older prompting literature suggests, but the evidence from recent model evaluations is clear: on strong reasoning-capable models like GPT-4, adding chain-of-thought scaffolding to tasks that don't require multi-step inference adds noise without adding accuracy.

Chain-of-Thought Prompting outperforms Zero-Shot Prompting on multi-step SEO reasoning tasks where intermediate judgments determine the final output. For a task like diagnosing a ranking drop, the agent needs to reason through traffic trends, index status, competitor movements, and content changes before arriving at a hypothesis. Zero-shot collapses that into a single inference step and frequently produces plausible-sounding but unsupported conclusions.

The practical rule: start with zero-shot. If output quality is inconsistent across similar inputs, move to few-shot. Use chain-of-thought only when the task has genuinely hidden subgoals, meaning the correct answer depends on intermediate conclusions that the agent must reach before it produces the final output. Adding "think step by step" to a meta description prompt wastes tokens and introduces variability.

How Does Few-Shot Prompting Compare to Zero-Shot for SEO Entity Extraction and Clustering?

Few-shot prompting improves entity extraction precision over zero-shot when entity labels are domain-specific or when boundaries between entity types are ambiguous. Few-shot wins on precision; zero-shot is faster and cheaper. The decision point is whether entity boundaries in your domain are ambiguous.

A controlled comparison using FAISS-selected similar examples showed precision improving from roughly 90% to 94% over a zero-shot baseline, with F1 gains concentrated in false-positive reduction. That 4-point precision gain matters because false positives in entity extraction corrupt downstream canonicalization and topical authority mapping. The mechanism is straightforward: examples in the prompt steer the model toward the label boundaries the practitioner actually wants, rather than the boundaries the model infers from training data alone.

For SEO keyword clustering, few-shot examples should not be selected for format alone. This is the mistake most SEO prompt libraries make: they treat few-shot examples as formatting templates. The semantic diversity of the chosen examples determines whether the agent generalizes to novel keyword clusters or overfits to the demonstrated niche. An agent whose few-shot examples are drawn entirely from e-commerce product pages will underperform on B2B SaaS keyword analysis, not because the instructions are wrong, but because the examples constrained its generalization space.

Three well-chosen diverse examples outperform six examples from the same niche. Zero-shot remains the right call for exploratory clustering where you don't yet have labeled examples, and for broad intent classification where the categories are standard enough that the model's prior knowledge is sufficient.

What Are the Core Prompt Pattern Types an SEO Agent Needs?

Seven patterns cover the full production surface, grouped by function: reasoning patterns, control patterns, and output patterns.

Reasoning patterns include Chain-of-Thought for multi-step inference tasks and ReAct for tasks requiring live data access. Zero-Shot Prompting is the baseline reasoning mode for well-bounded single-step tasks.

Control patterns are the ones most libraries skip. The System Prompt establishes the agent's operating constitution. Negative Constraints are explicit prohibitions that close known failure modes. The Self-Critique Loop asks the agent to review its own output before returning it. Self-consistency sampling generates multiple candidate outputs and selects the most consistent one.

Output patterns include Few-Shot Prompting for calibrating format and label boundaries, output schema directives for enforcing JSON or markdown structure, and task decomposition patterns for breaking multi-stage SEO workflows into sequential steps with explicit handoffs.

A production SEO agent needs all seven. The reasoning patterns handle the cognitive work. The control patterns prevent the failure modes that make SEO automation genuinely dangerous: hallucinated ranking claims, fabricated statistics, and confident algorithm assertions that have no basis in documented signals. The output patterns make results usable in CMS pipelines and audit workflows without manual reformatting.

The most underdeployed pattern in every SEO prompt library we've reviewed is the negative constraint. The section below covers why that matters.

How Do SEO Agent Prompt Patterns Differ Across Content Development and Technical Audit Tasks?

Content development prompts and technical audit prompts require fundamentally different architectures, and treating them as interchangeable is one of the most common reasons SEO agents underperform on structured data tasks.

A content brief prompt needs to know the target entity, primary intent, audience, competitor context, and the editorial constraints that govern tone and structure. The output is prose-adjacent: headings, paragraph structures, FAQ blocks, schema suggestions. The agent has room to synthesize and expand.

A technical audit prompt needs four things: a specific metric (clicks, impressions, crawl errors, index status), a time range, a filter or threshold (positions 5-15, mobile-only, pages with 100+ impressions), and an action request (compare, explain, flag, prioritize). The output is a structured finding, not a narrative. JSON schemas, error taxonomies, and crawl reports require instruction architectures that minimize ambiguity rather than leaving room for synthesis.

The failure mode we see most often: teams write a single "SEO agent" prompt and use it for both content generation and crawl analysis. The content tasks come back readable but shallow. The audit tasks come back as prose paragraphs when the downstream workflow needs parseable JSON. That's a pattern selection problem, not a prompt quality problem.

How Does ReAct-Style Prompting Change What an SEO Agent Can Reliably Do?

ReAct-style prompting transforms an SEO agent from a single-pass text generator into a tool-using loop that queries live SERP data, checks index status, and pulls crawl results mid-reasoning before committing to a conclusion. Static chain-of-thought reasons from frozen context; ReAct reasons from live evidence. For SEO tasks that depend on current data, that distinction determines whether the agent's output is defensible or just plausible.

The structure is Thought, Action, Observation, repeated until the agent reaches a final answer. A ReAct prompt explicitly defines which tools are available, the syntax for invoking them, and how to parse returned data. Without those definitions, the agent cannot execute the loop.

For SEO diagnosis tasks, this matters enormously. An agent reasoning about a ranking drop from training data will produce a list of plausible causes. A ReAct agent that queries Search Console data, checks for crawl errors, and inspects competitor movement mid-reasoning will produce a cause grounded in what is actually happening. The difference between those two outputs is the difference between a brainstorm and an audit.

ReAct is also the right pattern for tasks where the correct next step depends on what the previous step returned. Internal linking analysis, where the agent needs to check existing link structure before recommending additions, is a clear example. So is technical prioritization, where the agent needs to verify crawl error counts before ranking fixes by impact.

Does ReAct-Style Prompting Require a Different System Prompt Architecture Than Chain-of-Thought?

ReAct requires the same foundational system prompt architecture as chain-of-thought, plus three additional structural elements: an explicit tool inventory, invocation syntax, and observation-handling instructions. The underlying foundation, role, scope, constraints, and output format, does not change. The behavior contract does: instead of "reason step by step and produce an answer," the system prompt says "reason step by step, choose from these tools, observe the result, update your reasoning, repeat until done, then answer."

The tool inventory must list every callable tool with its parameters and expected return format. The invocation syntax must be unambiguous enough that the LLM produces parseable tool calls, not natural language descriptions of what it would like to do. The observation-handling instruction must tell the agent what to do when a tool returns an error, an empty result, or unexpected data.

Few-shot examples are especially valuable in ReAct prompts because the Thought-Action-Observation rhythm is non-obvious to models that haven't seen it demonstrated. One or two worked examples of the full loop, including a case where the first tool call returns insufficient data and the agent adjusts its next action, substantially improve loop reliability.

Can a ReAct Agent Replace RAG for Live SERP Grounding in SEO Workflows?

A ReAct agent handles the orchestration layer, deciding when to search and what to do with results, but it does not replace the retrieval layer that RAG provides for document-grounded, citation-backed outputs. The two patterns are complementary, not substitutes.

ReAct decides which tool to call next and what to do with what comes back. Retrieval-Augmented Generation fetches and ranks evidence before generation, grounding the final output in specific retrieved passages. For live SERP grounding, a developer guide describes the fix as real-time web retrieval fed into a retrieve-and-rerank pipeline, which is a RAG operation, not a ReAct operation.

The production pattern worth recommending for any SEO agent that needs both currency and defensibility: use ReAct as the control loop that decides when to retrieve and what to do next, and use RAG or direct retrieval as the evidence layer that grounds the final output. ReAct for branching logic and iterative checks. RAG for citation and fact-grounded drafting. Both together when the output must be current and auditable.

What Are Negative-Constraint Prompting Patterns and Why Do SEO Agents Need Them?

Negative constraints are explicit "do not" directives that close known failure modes before the agent has a chance to execute them, and they represent the single highest-leverage reliability gap in the current practitioner toolkit. Most SEO prompt libraries focus almost entirely on positive task framing: tell the agent what to produce, how to format it, and what persona to adopt. The explicit prohibition layer is nearly absent. Given that hallucinated ranking claims and fabricated algorithm facts are among the most damaging failure modes in SEO automation, that absence is costly.

Negative constraints work because they narrow the model's output space to a region the practitioner has already validated as safe. "Do not claim ranking outcomes unless supported by retrieved evidence." "Do not invent citation counts." "Do not extrapolate algorithm behavior beyond documented signals." "Do not assume current ranking positions without a live data source."

Research on prompting for LLM reliability, drawing on work behind prompting GPT-3 to be reliable and efficient, found that explicit prohibitions reduce model errors on fact-sensitive claims without requiring fine-tuning or retrieval infrastructure. The model doesn't need to be retrained to stop fabricating ranking position claims. It needs to be told, explicitly, that fabricating ranking position claims is prohibited.

The practical design pattern: state the positive goal first, then add a targeted exclusion block. "Write a content brief for a local service page targeting [entity]. Do not mention discounts, do not include claims that cannot be verified from the provided source material, and do not assume any specific ranking position for this page." Keep the exclusion block short, grouped, and tightly aligned with the actual failure modes you've observed.

Sub-patterns worth separating out: absolute bans for non-negotiable compliance violations; scope exclusions for what the agent should not cover in this task; format restrictions when the deliverable requires a specific shape; and quality guardrails for content-specific failure modes like keyword stuffing or speculative statistics.

Do Negative Constraints Reduce Hallucinated Ranking Claims Without Fine-Tuning?

Explicit prohibitions reduce hallucinated ranking claims without fine-tuning when paired with an escape valve that gives the model a sanctioned non-answer path. The mechanism is straightforward: "do not claim ranking outcomes unless supported by evidence" removes confident fabrication from the output space, but only if the model also has permission to say "I don't have sufficient data to make this claim." Without the escape valve, the model hedges rather than abstains, which produces a different kind of unreliable output.

Research on hallucination reduction consistently supports this two-part structure. Context-only instructions, "answer only from the provided documents; if the information is missing, say so," reduce unsupported outputs without touching model weights. OpenAI's hallucination research recommends placing confidence targets directly in the prompt or system message. Premise verification approaches, which flag false premises in the input before generation, reduce hallucination by catching the problem earlier in the reasoning chain.

For SEO agents, negative constraints work best as a system: prohibition plus escape valve plus retrieval grounding where available. Any one of those alone is weaker than the combination.

Should Negative Constraints Be Placed in the System Prompt or the Task Prompt?

Global prohibitions belong in the system prompt; task-specific exclusions belong in the task prompt. The decision test is simple: if the "do not" rule applies to every response the agent will ever produce in this deployment, it belongs in the system prompt. If it applies only to this particular deliverable, it belongs in the task prompt.

The attention-mechanism basis for this matters. Instructions placed higher in the system prompt receive more consistent compliance than instructions buried later. A prohibition placed at the top of the system prompt functions as a hard constraint. The same prohibition buried in the middle of a 3,000-word system prompt becomes, in practice, advisory.

No more than three or four negative constraints should appear in any single prompt layer. Overloading the constraint block reduces the model's ability to navigate toward a useful output, and it makes the prompt harder to debug when something goes wrong. If a constraint is important enough to include, it should appear near the top of whichever layer it belongs in.

How Does Self-Consistency Decoding Compare to Self-Critique Loops for SEO Hallucination Reduction?

Self-consistency sampling generates multiple reasoning paths and selects the most frequent conclusion through majority-vote aggregation; self-critique loops prompt the agent to inspect and revise its own output after generation. Self-consistency is a generation-time pattern. Self-critique is a post-generation pattern. They address different failure modes and are not alternatives to each other.

For SEO agents, self-consistency is the stronger broad filter. Hallucinations tend to vary across stochastic samples, while factual knowledge reproduces consistently. An agent that samples five completions and selects the most frequent conclusion about a ranking signal is less likely to report a fabricated position than an agent that commits to the first completion. The compute cost is real, but for fact-sensitive outputs like algorithm behavior claims or competitive ranking assertions, it is justified.

Self-critique loops are more useful for targeted checking: did the agent include a claim that isn't supported by the retrieved source material? Did it use a statistic that doesn't appear in the provided data? Those are questions a well-designed critique prompt can catch. But self-critique without external grounding is unreliable as a primary hallucination defense.

Can Self-Critique Loops Make SEO Agent Errors Worse Without External Validation?

Self-critique loops reinforce confident errors rather than correcting them when the agent lacks access to ground-truth data, because the model critiques its own output using the same knowledge and biases that produced the error in the first place. A Snorkel AI evaluation found a case where self-critique on a high-performance task degraded accuracy from 98% to 57%. The model corrected outputs that were already correct, based on a critique that was itself wrong.

Never use a self-critique loop as the final validation layer for fact-sensitive outputs. Use it as a first-pass filter that catches obvious structural problems, then validate against external sources. Crawl data, index checks, schema validators, and human editorial review are more reliable than introspective refinement for claims about rankings, algorithm behavior, or competitive positioning.

The architecture worth recommending: generate, verify with tools or retrieved data, revise only if verification fails. That sequence is more reliable than generate-critique-revise, because the verification step introduces a signal the model cannot fabricate.

How Does Prompt-Based SEO for AI Answer Engines Differ from Traditional On-Page Optimization?

Prompt-based SEO for AI answer engines optimizes content to be selected, cited, or summarized inside AI-generated responses, while traditional on-page SEO optimizes pages to rank in SERPs and earn clicks. The unit of optimization has changed.

Instruction patterns must simultaneously govern agent behavior and anticipate how the outputs will be interpreted by the same class of models producing them. Classic on-page frameworks were never designed for this recursive constraint. A keyword-optimized page that ranks in a traditional SERP is completely unsuitable for extraction by an AI answer engine if its structure doesn't support direct, self-contained answers.

The structural differences are significant. AI answer engines prefer direct declarative sentences, question-style headings, FAQ blocks, and standalone sections that models can extract without requiring the surrounding context. Traditional on-page SEO prefers keyword placement in titles, H1s, introductions, and at density thresholds across the page. Those two sets of requirements are not always compatible.

Google Search Generative Experience and similar AI-answer surfaces are accelerating this shift. An SEO agent writing content for current distribution needs to produce outputs that serve both audiences: the traditional ranking algorithm and the AI extraction layer. That requires instruction patterns the agent's system prompt must encode explicitly, not leave to the model's defaults.

Do Instruction Patterns for AI Answer Engine Optimization Conflict with Traditional Keyword Placement Rules?

Entity-salience and semantic coverage patterns for LLM parsing deprioritize exact-match keyword density that traditional on-page rules emphasize, but the resolution is to treat keywords as inputs to the prompt and validation targets for the output, not as the prompt's organizing principle. The conflict is about priority and execution rather than a fundamental incompatibility.

Traditional SEO guidance specifies the primary keyword in the title , H1, first paragraph, and at minimum density across the body. Instruction patterns for AI answer engines specify role, task, constraints, context, and format, with keywords appearing as context inputs rather than structural requirements.

The practical synthesis: a strong AI SEO prompt defines the target entity, primary keyword, audience, and search intent as context inputs. It instructs the agent to produce a title, H1, intro, and section structure. It then requires inclusion of the keyword and related entities in natural language, as a constraint on the output, not as the organizing logic of the prompt itself. That approach respects traditional keyword placement rules while keeping the instruction architecture focused on answer quality and extractability.

The tension becomes a conflict when practitioners try to use keyword placement rules as the primary prompt structure. A prompt organized around "include this keyword in these positions" produces outputs optimized for density, not for the semantic clarity and direct-answer structure that AI extraction systems prefer. Koray Tuğberk Gübür's entity-salience framework points directly at this: entity relationships and topical coverage depth matter more for AI answer inclusion than keyword repetition at prescribed positions.

Where Do SEO Practitioners Conflate the Prompt Layer with the Agent Orchestration Layer?

SEO practitioners conflate the prompt layer with the orchestration layer when they write a detailed instruction block and assume they have built an agentic workflow, when what they have actually built is instructions for one execution path. The prompt layer governs what the agent does in a single step: its role, task, constraints, and output format. The orchestration layer governs how work is allocated, sequenced, and supervised across multiple steps, tools, and agents. LangChain, AutoGPT, and custom orchestration layers handle routing, dependencies, validation, retries, logging, and multi-agent handoffs. A prompt cannot do those things, no matter how detailed it is.

The specific conflation points we see most often:

Context-window management assigned to prompts instead of chunking infrastructure. Practitioners write instructions like "summarize the most relevant sections of this document" and embed the entire document in the prompt, then wonder why the agent loses coherence on long crawl reports. Chunking and retrieval are orchestration-layer operations. A prompt instruction to "focus on the most relevant content" does not replace them.

Tool invocation logic embedded in prompt instructions rather than defined in the orchestration layer. "If you need current data, search for it" is not a tool-use instruction. It is a suggestion. Actual tool use requires the orchestration layer to define available tools, their parameters, and how returned data flows back into the agent's reasoning.

Multi-agent delegation described in a single prompt. Writing a prompt that says "act as a gap analyzer, then act as an NLP optimizer, then act as an internal linking agent" is not a multi-agent architecture. It is role-switching inside a single context window, which is brittle and unauditable. Real multi-agent delegation requires an orchestration layer that manages handoffs, context sharing, and validation between specialized agents.

Can Long-Context SEO Documents Be Handled by Prompt Instructions Alone Without Chunking Infrastructure?

Prompt instructions improve how an agent handles long-context SEO documents, but they do not replace chunking infrastructure for documents that exceed reliable context-window performance. Placing key evidence near the top of the prompt, repeating the task instruction at the end, and using explicit section headers all help. But the "lost in the middle" effect documented in long-context research is real: information in the center of a long prompt is harder for models to process than information near the beginning or end.

For large SEO documents, crawl reports, content inventories, keyword lists with thousands of terms, the right architecture is retrieval first, then prompting. Retrieve the relevant passages, then prompt the model with those passages rather than the full document. Moderate chunk sizes with global document metadata improve QA accuracy; overly large chunks reduce it by measurable margins.

Prompt instructions complement chunking infrastructure. Teams that treat them as a substitute will hit context-window limits and blame the model when the real problem is the system design.

Does Prompt Position in a Long System Prompt Affect Which SEO Directives the Agent Follows?

Critical SEO directives placed in the first 500 words of a system prompt receive systematically higher model compliance than the same directives buried later in a long instruction block. The transformer self-attention architecture distributes attention across token positions, and position-sensitive weighting means that instructions near the instruction head carry more weight than instructions near the end.

Brand voice rules, negative constraints, output schema requirements, and compliance guardrails belong at the top of the system prompt. Reference material, background context, and secondary guidelines can appear later. When a directive is critical enough to include, it is critical enough to front-load.

Reinforcing critical directives at both the beginning and end of a long system prompt is a documented mitigation for the middle-position weakness. For SEO agents with complex system prompts, a concise rules block in the first 300 words, stating the five to seven most important behavioral constraints, followed by the fuller instruction set, is the architecture that holds under pressure.

Which Prompt and Instruction Patterns Should Govern Your SEO Agent?

The prompt layer governs behavior; the orchestration layer governs architecture. Conflating them is the root failure in most SEO agent deployments, and no amount of prompt refinement fixes a system-design problem.

Within the prompt layer, the priority order is: system prompt first, with global negative constraints front-loaded in the first 300 words; task decomposition patterns that break multi-stage workflows into sequential steps with explicit handoffs; and output schema directives that enforce parseable formats for downstream pipelines.

For reasoning patterns, the decision is task-dependent. Zero-shot for well-bounded single-step tasks. Few-shot with semantically diverse examples for entity extraction and clustering. Chain-of-thought only when the task has genuinely hidden subgoals. ReAct for any task requiring live data, because the difference between reasoning from training data and reasoning from a live SERP query is the difference between a plausible output and a reliable one.

For hallucination mitigation, negative constraints are the highest-leverage intervention that requires no additional infrastructure. Self-consistency sampling is the strongest broad filter for fact-sensitive generation. Self-critique loops are useful for targeted post-generation checking, but only when paired with external validation. Don't use self-critique as the final gate on any SEO output that makes claims about rankings, algorithm behavior, or competitive positioning.

On prompt-based SEO for AI answer engines: instruction patterns must now account for how LLMs parse and surface content, not just how crawlers index it. Direct declarative answers, question-style headings, and extractable content blocks are structural requirements, not stylistic preferences.

If your SEO agent's system prompt doesn't contain at least three explicit negative constraints placed in the first 300 words, you are running a reliability experiment on your clients' sites. Add them before the next deployment.

Sources

1. Prompt Engineering for SEO: Proven Patterns, Agents & KPIs , AISO Hub.
2. Prompting for SEO , Agentic SEO Docs.
3. Prompt Engineering for Agentic AI , MachineLearningMastery.com.
4. Prompt Engineering for SEO Content , Clearscope.
5. 28 AI Prompt Ideas & Example Templates For SEO , Search Engine Journal.
6. Perfecting prompts for SEO content development , Search Engine Land.
7. Tip 7: Better AI prompts for SEO content , Yoast.
8. Prompt Engineering for SEO & Keyword Search Tools , Passionfruit.
9. Advanced Prompting Techniques for AI SEO , Dejan.ai.
10. 15 AI SEO Prompts for Automation in Content Marketing , AirOps.
11. 5 Powerful AI Prompts to Transform Your SEO Strategy in 2025 , The Innovative Owl.
12. Prompt-Based SEO: How SEOs Can Influence AI Answers Through Prompt Patterns , Single Grain.
13. Attention Is All You Need , Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, Illia Polosukhin, 2017, NeurIPS.
14. Language Models are Few-Shot Learners , Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, et al., 2020, OpenAI.
15. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models , Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, et al., 2022, Google Research / arXiv.
16. Self-Consistency Improves Chain of Thought Reasoning in Language Models , Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Denny Zhou, et al., 2022, Google Research / arXiv.
17. ReAct: Synergizing Reasoning and Acting in Language Models , Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, et al., 2022, arXiv.
18. Prompting GPT-3 To Be Reliable and Efficient , Ofir Press, Noah A. Smith, Mike Lewis, 2022, arXiv.