diff --git a/AGENTS.md b/AGENTS.md
index 6ab5542..97ecf40 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -11,14 +11,10 @@ Critical Thinking
 Fix root cause (not band-aid). Unsure: read more code; if still stuck, ask w/ short options. Unrecognized changes: assume other agent; keep going; focus your changes. If it causes issues, stop + ask user. Leave breadcrumb notes in thread.
 
 Attribution
-NEVER add links to Claude sessions in PR body or commits. Also never attribute commit or merge commit to coding agents, always use real user.
-
-Before committing, configure git user from environment variables:
-```bash
-git config user.name "$GIT_USER_NAME"
-git config user.email "$GIT_USER_EMAIL"
-```
-`GIT_USER_NAME` and `GIT_USER_EMAIL` must be set in the session.
+NEVER add links to Claude sessions in PR body or commits.
+Do not attribute commits or merge commits to coding agents by default; use the
+configured git user unless the repo owner asks for a specific attribution.
+Contributions from YOLOP agents may be attributed to YOLOP agents.
 
 ### Principles
 
diff --git a/README.md b/README.md
index 6f8f465..4a31426 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@ AI-friendly web content fetching tool designed for LLM consumption. Rust library
 - **HTTP fetching** - GET and HEAD methods with streaming support
 - **Pluggable fetchers** - URL-aware dispatch to specialized handlers for repos, docs, feeds, videos, papers, and more
 - **HTML-to-Markdown** - Built-in conversion optimized for LLMs
+- **Agent content focus** - Optional low-noise extraction mode for AI agents
 - **HTML-to-Text** - Plain text extraction with clean formatting
 - **Binary detection** - Returns metadata only for images, PDFs, etc.
 - **Timeout handling** - 1s first-byte, 30s body with partial content on timeout
@@ -212,7 +213,7 @@ response = tool.fetch("https://example.com")
 | `as_markdown` | bool? | Convert HTML to markdown |
 | `as_text` | bool? | Convert HTML to plain text |
 | `save_to_file` | string? | Save body to path (requires `FileSaver`) |
-| `content_focus` | string? | `"main"` strips boilerplate; `"full"`/unset returns everything |
+| `content_focus` | string? | `"full"`/unset returns everything; `"main"` strips semantic boilerplate; `"readable"` selects article-like content; `"agent"` selects the best low-noise strategy for AI agents |
 | `if_none_match` | string? | ETag for conditional `If-None-Match` |
 | `if_modified_since` | string? | Timestamp for conditional `If-Modified-Since` |
 
@@ -234,7 +235,7 @@ response = tool.fetch("https://example.com")
 | `error` | string? | Error message if failed |
 | `saved_path` | string? | Filesystem path when `save_to_file` succeeded |
 | `bytes_written` | int? | Bytes saved to file |
-| `metadata` | object? | Structured `PageMetadata` (title, description, links, headings, …) |
+| `metadata` | object? | Structured `PageMetadata` (title, description, links, headings, extraction method, …) |
 | `word_count` | int? | Word count of returned content |
 | `redirect_chain` | string[] | URLs visited during redirects (empty if none) |
 | `is_paywall` | bool? | Heuristic paywall signal (soft, not guaranteed) |
diff --git a/crates/fetchkit/src/convert.rs b/crates/fetchkit/src/convert.rs
index dc48618..792678a 100644
--- a/crates/fetchkit/src/convert.rs
+++ b/crates/fetchkit/src/convert.rs
@@ -891,6 +891,261 @@ pub fn strip_boilerplate(html: &str) -> String {
     strip_boilerplate_elements(html)
 }
 
+/// Extract the densest article-like content block for AI-agent consumption.
+///
+/// This is a deterministic, dependency-light readability pass. It favors semantic
+/// containers (`article`, `main`) and class/id names commonly used for content,
+/// penalizes link-heavy or boilerplate-looking blocks, and returns `None` when
+/// confidence is too low so callers can fall back to the existing main/full modes.
+pub fn extract_readable_content(html: &str) -> Option<String> {
+    let candidates = collect_readable_candidates(html);
+    let best = candidates
+        .into_iter()
+        .filter(|candidate| candidate.word_count >= 20)
+        .max_by_key(|candidate| candidate.score)?;
+
+    if best.score < 100 {
+        return None;
+    }
+
+    Some(strip_boilerplate_elements(&best.html))
+}
+
+#[derive(Debug)]
+struct ReadableCandidate {
+    html: String,
+    score: i64,
+    word_count: usize,
+}
+
+fn collect_readable_candidates(html: &str) -> Vec<ReadableCandidate> {
+    let mut candidates = Vec::new();
+    for tag_name in ["article", "main", "section", "div"] {
+        collect_tag_candidates(html, tag_name, &mut candidates);
+    }
+    candidates
+}
+
+fn collect_tag_candidates(html: &str, tag_name: &str, candidates: &mut Vec<ReadableCandidate>) {
+    let lower = html.to_ascii_lowercase();
+    let open_prefix = format!("<{tag_name}");
+    let mut search_start = 0usize;
+
+    while let Some(relative_start) = lower[search_start..].find(&open_prefix) {
+        let tag_start = search_start + relative_start;
+        let after_name = tag_start + open_prefix.len();
+        let Some(next) = lower[after_name..].chars().next() else {
+            break;
+        };
+        if !(next.is_ascii_whitespace() || next == '>' || next == '/') {
+            search_start = after_name;
+            continue;
+        }
+
+        let Some(open_end_relative) = lower[tag_start..].find('>') else {
+            break;
+        };
+        let open_end = tag_start + open_end_relative;
+        let open_tag = &html[tag_start + 1..open_end];
+
+        if tag_name == "div" && !looks_like_content_container(open_tag) {
+            search_start = open_end + 1;
+            continue;
+        }
+
+        let Some(close_start) = find_matching_close(&lower, tag_name, tag_start, open_end + 1)
+        else {
+            break;
+        };
+        let inner = html[open_end + 1..close_start].to_string();
+        if let Some(candidate) = score_readable_candidate(open_tag, inner) {
+            candidates.push(candidate);
+        }
+
+        search_start = open_end + 1;
+    }
+}
+
+fn find_matching_close(
+    lower_html: &str,
+    tag_name: &str,
+    tag_start: usize,
+    content_start: usize,
+) -> Option<usize> {
+    let open_prefix = format!("<{tag_name}");
+    let close_prefix = format!("</{tag_name}");
+    let mut depth = 1i32;
+    let mut cursor = content_start;
+
+    while cursor < lower_html.len() {
+        let next_open = lower_html[cursor..].find(&open_prefix).map(|i| cursor + i);
+        let next_close = lower_html[cursor..].find(&close_prefix).map(|i| cursor + i);
+
+        match (next_open, next_close) {
+            (Some(open), Some(close)) if open < close => {
+                let after_name = open + open_prefix.len();
+                let is_same_tag = lower_html[after_name..]
+                    .chars()
+                    .next()
+                    .map(|ch| ch.is_ascii_whitespace() || ch == '>' || ch == '/')
+                    .unwrap_or(false);
+                if is_same_tag {
+                    if let Some(end) = lower_html[open..].find('>') {
+                        let tag = &lower_html[open..open + end + 1];
+                        if !tag.ends_with("/>") {
+                            depth += 1;
+                        }
+                        cursor = open + end + 1;
+                    } else {
+                        return None;
+                    }
+                } else {
+                    cursor = after_name;
+                }
+            }
+            (_, Some(close)) => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(close);
+                }
+                let end = lower_html[close..].find('>')?;
+                cursor = close + end + 1;
+            }
+            _ => return None,
+        }
+    }
+
+    debug_assert!(tag_start < lower_html.len());
+    None
+}
+
+fn looks_like_content_container(open_tag: &str) -> bool {
+    let lower = open_tag.to_lowercase();
+    let positive = [
+        "article", "content", "entry", "main", "markdown", "post", "prose", "readme", "story",
+        "text",
+    ];
+    let negative = [
+        "ad",
+        "banner",
+        "breadcrumb",
+        "comment",
+        "footer",
+        "header",
+        "menu",
+        "nav",
+        "related",
+        "share",
+        "sidebar",
+    ];
+
+    positive.iter().any(|needle| lower.contains(needle))
+        && !negative.iter().any(|needle| lower.contains(needle))
+}
+
+fn score_readable_candidate(open_tag: &str, html: String) -> Option<ReadableCandidate> {
+    let text = html_to_text(&html);
+    let word_count = text.split_whitespace().count();
+    if word_count == 0 {
+        return None;
+    }
+
+    let link_word_count = link_text_word_count(&html);
+    let paragraph_count = html.matches("<p").count() + html.matches("<P").count();
+    let heading_count = html.matches("<h1").count()
+        + html.matches("<h2").count()
+        + html.matches("<h3").count()
+        + html.matches("<H1").count()
+        + html.matches("<H2").count()
+        + html.matches("<H3").count();
+    let lower_tag = open_tag.to_lowercase();
+    let semantic_bonus = if lower_tag.starts_with("article") {
+        120
+    } else if lower_tag.starts_with("main") || lower_tag.contains("role=\"main\"") {
+        90
+    } else if looks_like_content_container(open_tag) {
+        70
+    } else {
+        20
+    };
+    let boilerplate_penalty = if looks_like_boilerplate(&lower_tag) {
+        200
+    } else {
+        0
+    };
+
+    let score = (word_count as i64 * 8)
+        + (paragraph_count as i64 * 20)
+        + (heading_count as i64 * 12)
+        + semantic_bonus
+        - (link_word_count as i64 * 6)
+        - boilerplate_penalty;
+
+    Some(ReadableCandidate {
+        html,
+        score,
+        word_count,
+    })
+}
+
+fn looks_like_boilerplate(lower_tag: &str) -> bool {
+    [
+        "ad",
+        "banner",
+        "breadcrumb",
+        "comment",
+        "footer",
+        "header",
+        "menu",
+        "nav",
+        "related",
+        "share",
+        "sidebar",
+    ]
+    .iter()
+    .any(|needle| lower_tag.contains(needle))
+}
+
+fn link_text_word_count(html: &str) -> usize {
+    let mut words = 0usize;
+    let mut chars = html.chars().peekable();
+    let mut in_link = false;
+    let mut link_text = String::new();
+
+    while let Some(c) = chars.next() {
+        if c == '<' {
+            let mut tag = String::new();
+            while let Some(&next) = chars.peek() {
+                if next == '>' {
+                    chars.next();
+                    break;
+                }
+                tag.push(chars.next().unwrap());
+            }
+
+            let tag_lower = tag.to_lowercase();
+            let tag_name = if let Some(stripped) = tag_lower.strip_prefix('/') {
+                stripped.split_whitespace().next().unwrap_or("")
+            } else {
+                tag_lower.split_whitespace().next().unwrap_or("")
+            };
+            if tag_name == "a" {
+                if tag_lower.starts_with('/') {
+                    words += link_text.split_whitespace().count();
+                    link_text.clear();
+                    in_link = false;
+                } else {
+                    in_link = true;
+                }
+            }
+        } else if in_link {
+            link_text.push(decode_entity(c, &mut chars));
+        }
+    }
+
+    words
+}
+
 /// Extract content from `<main>` or `<article>` tag if present.
 fn extract_main_content(html: &str) -> Option<String> {
     // Try <main> first, then <article>
@@ -1549,6 +1804,48 @@ mod tests {
         assert!(!result.contains("Site header"));
     }
 
+    #[test]
+    fn test_extract_readable_content_prefers_article_over_nav() {
+        let html = r#"
+            <nav><a href="/a">Home</a><a href="/b">Products</a><a href="/c">Pricing</a></nav>
+            <article>
+                <h1>Useful Agent Content</h1>
+                <p>This paragraph contains the important answer an AI agent should read and use.</p>
+                <p>The content block has enough natural language to score above short navigation.</p>
+            </article>
+            <aside>Related links and promotional clutter</aside>
+        "#;
+
+        let result = extract_readable_content(html).unwrap();
+        assert!(result.contains("Useful Agent Content"));
+        assert!(result.contains("important answer"));
+        assert!(!result.contains("Products"));
+        assert!(!result.contains("promotional clutter"));
+    }
+
+    #[test]
+    fn test_extract_readable_content_uses_content_class() {
+        let html = r#"
+            <div class="sidebar">Menu widgets and account links</div>
+            <div class="post-content">
+                <h2>Documentation Section</h2>
+                <p>Agents need this implementation detail when they answer questions.</p>
+                <p>This second paragraph gives the extractor enough signal to select the block.</p>
+            </div>
+        "#;
+
+        let result = extract_readable_content(html).unwrap();
+        assert!(result.contains("Documentation Section"));
+        assert!(result.contains("implementation detail"));
+        assert!(!result.contains("Menu widgets"));
+    }
+
+    #[test]
+    fn test_extract_readable_content_returns_none_for_low_signal_html() {
+        let html = r#"<div class="content"><a href="/one">One</a><a href="/two">Two</a></div>"#;
+        assert!(extract_readable_content(html).is_none());
+    }
+
     #[test]
     fn test_html_to_markdown_links() {
         let html = r#"<p>Visit <a href="https://example.com">Example Site</a> today.</p>"#;
diff --git a/crates/fetchkit/src/fetchers/default.rs b/crates/fetchkit/src/fetchers/default.rs
index c30c690..bed7851 100644
--- a/crates/fetchkit/src/fetchers/default.rs
+++ b/crates/fetchkit/src/fetchers/default.rs
@@ -9,8 +9,9 @@
 
 use crate::client::FetchOptions;
 use crate::convert::{
-    extract_headings, extract_metadata, filter_excessive_newlines, html_to_markdown, html_to_text,
-    is_html, is_markdown_content_type, is_plain_text_content_type, strip_boilerplate,
+    extract_headings, extract_metadata, extract_readable_content, filter_excessive_newlines,
+    html_to_markdown, html_to_text, is_html, is_markdown_content_type, is_plain_text_content_type,
+    strip_boilerplate,
 };
 use crate::error::FetchError;
 use crate::fetchers::Fetcher;
@@ -332,9 +333,11 @@ impl Fetcher for DefaultFetcher {
         // THREAT[TM-DOS-006]: Conversion input is bounded by max_body_size
         let is_html_content = is_html(&meta.content_type, &content);
         let wants_main = request.wants_main_content();
+        let wants_readable = request.wants_readable_content();
+        let wants_agent = request.wants_agent_content();
 
         // Extract structured metadata from HTML content (before boilerplate stripping)
-        let page_metadata = if is_html_content {
+        let mut page_metadata = if is_html_content {
             let mut pm = extract_metadata(&content);
             pm.headings = extract_headings(&content);
             if pm.is_empty() {
@@ -346,31 +349,46 @@ impl Fetcher for DefaultFetcher {
             None
         };
 
-        let (format, final_content) =
+        let (format, final_content, extraction_method) =
             if is_markdown_content_type(&meta.content_type) && wants_markdown {
                 // Server already returned markdown — skip conversion
                 debug!("Content-type is markdown; skipping HTML conversion");
-                ("markdown".to_string(), content)
+                ("markdown".to_string(), content, Some("native_markdown"))
             } else if is_plain_text_content_type(&meta.content_type) && wants_text {
                 // Server already returned plain text — skip conversion
                 debug!("Content-type is plain text; skipping HTML conversion");
-                ("text".to_string(), content)
+                ("text".to_string(), content, Some("native_text"))
             } else if is_html_content {
-                // Strip boilerplate before conversion if content_focus is "main"
-                let html = if wants_main {
-                    strip_boilerplate(&content)
+                let (html, method) = if wants_agent {
+                    if let Some(readable) = extract_readable_content(&content) {
+                        (readable, "agent_readable")
+                    } else {
+                        (strip_boilerplate(&content), "agent_main")
+                    }
+                } else if wants_readable {
+                    if let Some(readable) = extract_readable_content(&content) {
+                        (readable, "readable")
+                    } else {
+                        (strip_boilerplate(&content), "readable_fallback_main")
+                    }
+                } else if wants_main {
+                    (strip_boilerplate(&content), "main")
                 } else {
-                    content
+                    (content, "full")
                 };
                 if wants_markdown {
-                    ("markdown".to_string(), html_to_markdown(&html))
+                    (
+                        "markdown".to_string(),
+                        html_to_markdown(&html),
+                        Some(method),
+                    )
                 } else if wants_text {
-                    ("text".to_string(), html_to_text(&html))
+                    ("text".to_string(), html_to_text(&html), Some(method))
                 } else {
-                    ("raw".to_string(), html)
+                    ("raw".to_string(), html, Some(method))
                 }
             } else {
-                ("raw".to_string(), content)
+                ("raw".to_string(), content, Some("raw"))
             };
 
         // Apply newline filtering
@@ -383,6 +401,9 @@ impl Fetcher for DefaultFetcher {
 
         // Compute quality signals
         let word_count = count_words(&final_content);
+        if let (Some(metadata), Some(method)) = (&mut page_metadata, extraction_method) {
+            metadata.extraction_method = Some(method.to_string());
+        }
 
         Ok(FetchResponse {
             url: final_url,
@@ -992,6 +1013,57 @@ mod tests {
             .contains("Just plain text"));
     }
 
+    #[tokio::test]
+    async fn test_agent_content_focus_prefers_readable_body() {
+        let server = MockServer::start().await;
+        let html = r#"
+            <html>
+                <body>
+                    <nav><a href="/home">Home</a><a href="/pricing">Pricing</a></nav>
+                    <article>
+                        <h1>Agent Ready Article</h1>
+                        <p>This is the useful content an autonomous AI agent should receive.</p>
+                        <p>The second paragraph gives the readability scorer a clear signal.</p>
+                    </article>
+                    <aside>Related stories and subscription widgets</aside>
+                </body>
+            </html>
+        "#;
+        Mock::given(method("GET"))
+            .and(path("/article"))
+            .respond_with(
+                ResponseTemplate::new(200)
+                    .set_body_string(html)
+                    .insert_header("content-type", "text/html"),
+            )
+            .mount(&server)
+            .await;
+
+        let fetcher = DefaultFetcher::new();
+        let options = FetchOptions {
+            enable_markdown: true,
+            dns_policy: DnsPolicy::allow_all(),
+            ..Default::default()
+        };
+        let request = FetchRequest::new(format!("{}/article", server.uri()))
+            .as_markdown()
+            .content_focus("agent");
+        let response = fetcher.fetch(&request, &options).await.unwrap();
+        let content = response.content.as_deref().unwrap();
+
+        assert!(content.contains("# Agent Ready Article"), "{content}");
+        assert!(content.contains("useful content"), "{content}");
+        assert!(!content.contains("Pricing"), "{content}");
+        assert!(!content.contains("subscription widgets"), "{content}");
+        assert_eq!(
+            response
+                .metadata
+                .as_ref()
+                .and_then(|meta| meta.extraction_method.as_deref()),
+            Some("agent_readable")
+        );
+    }
+
     #[tokio::test]
     async fn test_markdown_content_type_without_markdown_request_returns_raw() {
         let server = MockServer::start().await;
diff --git a/crates/fetchkit/src/lib.rs b/crates/fetchkit/src/lib.rs
index 9ae2ce2..64a20cd 100644
--- a/crates/fetchkit/src/lib.rs
+++ b/crates/fetchkit/src/lib.rs
@@ -87,7 +87,8 @@ mod types;
 
 pub use client::{batch_fetch, batch_fetch_with_options, fetch, fetch_with_options, FetchOptions};
 pub use convert::{
-    extract_headings, extract_metadata, html_to_markdown, html_to_text, strip_boilerplate,
+    extract_headings, extract_metadata, extract_readable_content, html_to_markdown, html_to_text,
+    strip_boilerplate,
 };
 pub use dns::DnsPolicy;
 pub use error::{FetchError, ToolError};
diff --git a/crates/fetchkit/src/tool.rs b/crates/fetchkit/src/tool.rs
index dc25df4..b8298f1 100644
--- a/crates/fetchkit/src/tool.rs
+++ b/crates/fetchkit/src/tool.rs
@@ -1005,6 +1005,14 @@ fn build_help(tool: &Tool) -> String {
         ));
     }
 
+    rows.push(table_row(
+        "content_focus",
+        "string",
+        "no",
+        "\"full\"",
+        parameter_description(tool.locale(), "content_focus"),
+    ));
+
     let adapters = if tool.enable_save_to_file {
         if is_ukrainian(tool.locale()) {
             "- `FileSaver` (необов’язковий): потрібен, коли задано `save_to_file`.\n"
@@ -1091,11 +1099,13 @@ fn parameter_description(locale: &str, field: &str) -> &'static str {
         (true, "as_markdown") => "Перетворити HTML у markdown",
         (true, "as_text") => "Перетворити HTML у plain text",
         (true, "save_to_file") => "Шлях призначення, визначений адаптером",
+        (true, "content_focus") => "`full`, `main`, `readable`, або `agent`",
         (false, "url") => "HTTP/HTTPS URL, or a bare domain URL normalized to `https://`",
         (false, "method") => "`GET` or `HEAD`",
         (false, "as_markdown") => "Convert HTML to markdown",
         (false, "as_text") => "Convert HTML to plain text",
         (false, "save_to_file") => "Adapter-defined destination path",
+        (false, "content_focus") => "`full`, `main`, `readable`, or `agent`",
         _ => "",
     }
 }
diff --git a/crates/fetchkit/src/types.rs b/crates/fetchkit/src/types.rs
index cb5d692..ae53993 100644
--- a/crates/fetchkit/src/types.rs
+++ b/crates/fetchkit/src/types.rs
@@ -95,8 +95,11 @@ pub struct FetchRequest {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub save_to_file: Option<String>,
 
-    /// Content extraction focus: "main" strips nav/footer/aside boilerplate,
-    /// "full" (default) returns everything.
+    /// Content extraction focus:
+    /// - "full" (default) returns everything
+    /// - "main" strips semantic boilerplate
+    /// - "readable" selects the densest article-like content block
+    /// - "agent" selects the best low-noise content strategy for AI agents
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub content_focus: Option<String>,
 
@@ -157,7 +160,7 @@ impl FetchRequest {
         self
     }
 
-    /// Set content focus mode ("main" or "full")
+    /// Set content focus mode ("full", "main", "readable", or "agent")
     pub fn content_focus(mut self, focus: impl Into<String>) -> Self {
         self.content_focus = Some(focus.into());
         self
@@ -197,6 +200,22 @@ impl FetchRequest {
             .map(|f| f.eq_ignore_ascii_case("main"))
             .unwrap_or(false)
     }
+
+    /// Check if readable content focus is requested.
+    pub fn wants_readable_content(&self) -> bool {
+        self.content_focus
+            .as_deref()
+            .map(|f| f.eq_ignore_ascii_case("readable"))
+            .unwrap_or(false)
+    }
+
+    /// Check if agent content focus is requested.
+    pub fn wants_agent_content(&self) -> bool {
+        self.content_focus
+            .as_deref()
+            .map(|f| f.eq_ignore_ascii_case("agent"))
+            .unwrap_or(false)
+    }
 }
 
 fn canonical_fetch_url(raw_url: &str) -> Result<String, FetchError> {
@@ -297,6 +316,10 @@ pub struct PageMetadata {
     /// Headings outline (e.g. `["# Title", "## Section 1", "## Section 2"]`)
     #[serde(skip_serializing_if = "Vec::is_empty", default)]
     pub headings: Vec<String>,
+
+    /// Content extraction method used for the returned content.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extraction_method: Option<String>,
 }
 
 impl PageMetadata {
@@ -311,6 +334,7 @@ impl PageMetadata {
             && self.modified_date.is_none()
             && self.links.is_empty()
             && self.headings.is_empty()
+            && self.extraction_method.is_none()
     }
 }
 
diff --git a/specs/initial.md b/specs/initial.md
index 3319975..1de16ce 100644
--- a/specs/initial.md
+++ b/specs/initial.md
@@ -70,8 +70,11 @@ Provide a builder to configure tool options, including:
   - `as_markdown: bool` (optional, feature-gated)
   - `as_text: bool` (optional, feature-gated)
   - `save_to_file: Option<String>` (optional, feature-gated via `enable_save_to_file`)
-  - `content_focus: Option<String>` ("main" strips boilerplate; "full" or unset returns
-    everything)
+  - `content_focus: Option<String>` controls extraction before HTML conversion:
+    - `"full"` or unset returns everything
+    - `"main"` strips semantic boilerplate
+    - `"readable"` selects the densest article-like content block, falling back to `"main"`
+    - `"agent"` selects the best low-noise strategy for AI agents, currently readable-first then `"main"`
   - `if_none_match: Option<String>` (sets `If-None-Match` for conditional requests)
   - `if_modified_since: Option<String>` (sets `If-Modified-Since` for conditional requests)
 - `HttpMethod` enum: `Get`, `Head`
@@ -105,6 +108,9 @@ Provide a builder to configure tool options, including:
   - `modified_date: Option<String>` (from `article:modified_time`)
   - `links: Vec<PageLink>` (extracted anchors with text + href)
   - `headings: Vec<String>` (outline like `["# Title", "## Section 1"]`)
+  - `extraction_method: Option<String>` (`"full"`, `"main"`, `"readable"`,
+    `"readable_fallback_main"`, `"agent_readable"`, `"agent_main"`, `"native_markdown"`,
+    `"native_text"`, or `"raw"`)
 - `FetchError` enum
   - Missing url
   - Invalid url scheme