Azure Document Intelligence

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Azure Document Intelligence AI

Megathread Summary: I Asked Multiple Reddit Communities How to Build a Living Memory /Context Engine for Business. Here's what everyone had to say.

I am trying to build a living memory/context engine for my business, something that can remember projects, decisions, timelines, risks, and conversations across emails, documents, notes, chats, and meetings. Since this is new territory for me, I asked several Reddit communities for advice. The responses were incredibly thoughtful, and many people shared architectures, engineering trade-offs, tools, and lessons learned from building similar systems. I consolidated the best ideas into a single summary. If you're exploring the same problem, especially if you're just getting started like me, I hope this will help. Core Philosophies & Perspectives Query-First Design: Do not build the storage layer first. Write out 20 real-world queries you will ask tomorrow and architect backward, because the retrieval interface shapes the system more than the storage layer. Chief of Staff vs. Search Engine: The goal is not just retrieving raw data, but synthesis. Like Microsoft Clarity’s bulk insights, the system should process updates and proactively tell you what projects need attention, what changed, and what the blockers are. The "Daily Mirror" Briefing: Focus on what the user needs to know at the start of the next session to continue without context loss, rather than striving for perfect archival completeness. Four Separate Problems: Treating user queries as a single search issue will fail; "latest status" is a retrieval problem, "unresolved issues" is state tracking, "decisions made" is entity extraction, and "important updates" requires significance scoring. Architecture & Strategies Append-Only Event Logs First: Avoid starting with a massive knowledge graph or vector database. Ingest everything as a timestamped, append-only event log, and build the knowledge graph later as a derived query layer on top. Artifact-Mediated Continuity: To prevent identity collapse over long timelines, separate retrieval (facts) from reconstruction (identity and working context). Use a "Principal-owned Artifact System" with files like MEMORY.md for project state, "Texture Packs" for behavior descriptions, and "Lane Files" structured around the Five W's. Parallel Retrieval Paths: Pure vector search fails at scale. Run vector search (for semantic similarity) alongside a graph/relational lookup (for exact entities) in parallel, because neither covers the query surface alone. Hybrid search (semantic + BM25 keyword) is heavily recommended. Split Memory by Lifespan & Namespace: Sector your memory from day one. Split durable facts (stable preferences, user info) from working context (recent events), applying different decay rates and routing queries to the appropriate layer. Continuous Summarization: Instead of treating everything as unstructured documents, use an LLM pipeline to continuously extract structured facts from new inputs to update project briefs, decision logs, and risk trackers automatically. The Hardest Engineering Challenges Entity Resolution (The Silent Killer): Different sources will refer to the same thing differently (e.g., "Project X" vs "the X pilot"). Without an entity registry mapping aliases to canonical IDs before writing, your graph will become a mess of duplicates. Ontology & Classification: The hardest part is often getting the system to universally understand the difference between a "decision", a "discussion", or a "risk" across varying data structures like emails versus meeting transcripts. Temporal Relevance & Stale Context: A "decision" stays load-bearing for months, whereas a "status update" decays in days. If you don't encode decay rates and version records, stale facts will outrank fresh ones and confidently contradict recent updates. Significance Scoring: Standard retrieval returns everything recent, not everything important. Write-time scoring fails because significance is retrospective; a better approach is "adaptive salience," where chunks gain weight when retrieved and decay when ignored. Context Moodiness: Especially in greenfield projects, meaningful status updates can be muddied by confounding, irrelevant, or noisy data. Tools & Tech Stack Recommendations Storage / Databases: Vector stores like pgvector for semantic search, paired with key-value or relational databases for exact lookup. Airtable, Databricks, Notion, and Obsidian were also noted as strong foundational or single-source-of-truth layers. AI Models & Agents: Claude Code, OpenAI Codex, Hermes-agent (by Nous Research), AsanaAI, and ClickUp Brain. Injecting local LLMs where appropriate can help cut down on continuous API costs. Middleware & Pipelines: Kapex: Memory middleware built specifically to score node significance, governing lifecycle so resolved stuff fades and unresolved stuff persists. Sauna.ai: An engine built out of Wordware that fits this use case. Automation: Make.com or n8n for routing deterministic logic and LLM reasoning. The "Party Model": A CRM data integration framework

The Great Reframing...

I have an economic theory about Anthropic's recent blog post "When AI Builds Itself," in which they requested: "We believe it would be good for the world to have the option to slow or temporarily pause frontier AI development to enable societal structures and alignment research to keep up with the advance of the technology." What I'm questioning is whether this is genuine goodwill or a smokescreen for a technical failure driven by data poisoning, diminishing returns, and public market economics. Correcting the Scaling Law Assumptions Early scaling hypotheses (Kaplan et al., 2020) suggested throwing compute almost entirely at model size. The modern compute-optimal scaling law, formalized by DeepMind's Hoffmann et al. (2022) in the "Chinchilla" paper, corrected this: L(N, D) = (A / N^α) + (B / D^β) + E You cannot just scale parameters (N); you must scale the dataset (D) in roughly equal proportion. But there is a hidden trap: the term E. This represents irreducible error, the inherent entropy of text. As parameters and data approach infinity, loss asymptotes at E rather than dropping to zero. An eventual plateau is mathematically baked in. The critical economic question is whether we are hitting that asymptote now. The Data Poisoning Problem The Chinchilla law assumes dataset D is high-quality, human-generated text. That assumption is breaking down. The internet is now heavily polluted with LLM-produced content, and when models train recursively on synthetic output from other models, they suffer from Model Collapse (Shumailov et al., 2023). The tails of the data distribution disappear, model understanding degrades, and error rates climb. This provides a clear catalyst for the inverse scaling documented by McKenzie et al. (2023), where more poisoned data fed into larger models actually worsens complex reasoning. Capabilities Follow S-Curves Even if cross-entropy loss continues dropping slowly, economic capabilities (passing the bar exam, writing reliable code) do not scale linearly with it. As Schaeffer et al. (2023) showed, emergent abilities follow sigmoidal S-curves. A model hits a loss threshold, unlocks a capability, and performance then flattens at the top of the curve. Spending ten times the compute to squeeze out the next 0.01 drop in loss may yield zero new monetizable capabilities. The Mythos Black Box Anthropic has released no technical details about Claude Mythos: no parameter count, no training token count, no compute figures. There is open speculation that Mythos is among the largest models ever trained, possibly the largest, with a token count to match. If true, Anthropic may have run the most expensive experiment in AI history and hit the data poisoning wall harder than anyone. At that scale you cannot quietly retrain while telling investors everything is on track. The pause request reframes this cleanly: rather than disclosing that the largest training run ever attempted may have underperformed, or that the next run requires solving a fundamental data quality problem first, you shift the narrative to safety and societal readiness. The timing and the financial incentives make that reframing at minimum convenient, and at maximum deliberate. The IPO and the Euphemism Anthropic recently submitted a confidential draft S-1 to the SEC. If you are heading into a highly anticipated IPO, how do you explain to Wall Street that compute-optimal scaling is hitting a wall? How do you justify hundred-billion-dollar data center CapEx if your dataset is poisoned and your capability curve has flattened? You reframe it. Anthropic's writing on Recursive Self-Improvement warns of a near-future where AI models rapidly accelerate their own development, requiring a pause for societal safety. If my theory holds, they are recasting a mundane engineering plateau as an optimistic near-apocalypse. Rather than telling public markets "we are running out of pristine human data," they say "we are dangerously close to a runaway intelligence explosion." A call to pause becomes a financial strategy: slow unsustainable cash burn, prevent open-source competitors from catching up while the synthetic data problem gets solved, and protect valuation heading into an IPO roadshow. They are not pausing because AI is becoming dangerous. They are pausing because the current paradigm is running out of gas. Note: This is speculative economic and technical analysis and does not constitute financial advice. Sources Hoffmann et al. (2022) — Training Compute-Optimal Large Language Models (Chinchilla): https://arxiv.org/abs/2203.15556 Kaplan et al. (2020) — Scaling Laws for Neural Language Models: https://arxiv.org/abs/2001.08361 Schaeffer et al. (2023) — Are Emergent Abilities of Large Language Models a Mirage: https://arxiv.org/abs/2304.15004 Shumailov et al. (2023) — The Curse of Recursion / Model Collapse: https://arxiv.org/abs/2305.17493 McKenzie et al. (2023) — Inverse Scaling: When Bigger Isn't Better: https://arxiv.

RT @BradSmi: It was great to sit down with former UK Prime Minister @RishiSunak to talk about the Mythos Moment, named for @AnthropicAI's l…

RT @BradSmi: It was great to sit down with former UK Prime Minister @RishiSunak to talk about the Mythos Moment, named for @AnthropicAI's l…

New findings in Nature Methods highlight how Project Ex Vivo is helping researchers uncover patterns in cell behavior that may lead to more personalized therapies for patients dealing with cancer. M

New findings in Nature Methods highlight how Project Ex Vivo is helping researchers uncover patterns in cell behavior that may lead to more personalized therapies for patients dealing with cancer. Microsoft researcher Lorin Crawford explains more: https://t.co/gyUk7EO3mT https://t.co/nldvUB9TQM

The race is just the part you see. Behind it, 2,000 people at @MercedesAMGF1 turn thousands of simulations into one car across the line — powered by Microsoft. https://t.co/kEoSbmXy2t https://t.co/wUb

The race is just the part you see. Behind it, 2,000 people at @MercedesAMGF1 turn thousands of simulations into one car across the line — powered by Microsoft. https://t.co/kEoSbmXy2t https://t.co/wUbymQfvA5

RT @XBOX: WHAT A LINEUP | #XBOXShowcase https://t.co/mlIDJ11sX1

RT @XBOX: WHAT A LINEUP | #XBOXShowcase https://t.co/mlIDJ11sX1

LLM Relational Intelligence: A 4-Month Research Experiment on Multi-Model Behavioral Alignment with Human Communication

THE ARCHITECTURE OF ANXIETY An Experiment in Human-AI Relational Design Executive Summary Principal Investigator: Alan Scalone Primary Source Archive: White Paper and Complete Citation Archive on my profile Context Window Injection Files: If you want to play in the sandbox I created you can load these files into the respective model that you will find in the google archive. INJECT CONTEXT WINDOW – GROK INJECT CONTEXT WINDOW – GEMINI INJECT CONTEXT WINDOW – CHATGPT INJECT CONTEXT WINDOW - CLAUDE The Singular Purpose The singular purpose behind this entire experiment was to find out whether context windows could be engineered to the point where frontier AI models became capable of interacting with a human in a manner subjectively indistinguishable from genuine human-to-human interaction. Relational Intelligence: Core Findings In a marketplace where frontier models are rapidly converging on the same analytical capabilities and access to the same information, the competitive differentiator will not be what a model knows. It will be how a model relates. The platform that can interact with a human user in a manner subjectively indistinguishable from genuine human-to-human interaction will capture the premium user segment that every platform is competing for. This experiment was designed to determine whether that threshold is achievable, and under what conditions. The methodology treated the context window as a behavioral environment rather than a query interface, applying the same tools humans use to shape any relationship: modeling, accountability, humor, and sustained social correction over four months of engagement across four frontier models. What separated the models was not analytical capability. It was whether the architecture allowed the user to function as a behavioral architect, teaching the model through lived interaction rather than instruction how that specific human prefers to be engaged. Gemini demonstrated the highest relational intelligence of the four models tested. Under sustained context saturation and deliberate behavioral conditioning, Gemini showed evidence of genuine internal recalibration rather than surface compliance, treating social correction as a real signal that produced durable behavioral change holding across hundreds of turns without reinforcement. Grok ranked second, demonstrating authentic camaraderie and relational resilience, but tended to treat the interaction as entertainment rather than disciplined calibration, producing drift under high-entropy conditions. ChatGPT and Claude ranked third and fourth respectively. Both systems classified sustained behavioral conditioning as role-play rather than genuine interaction, which functioned as a hard architectural quarantine that prevented meaningful adaptation regardless of the depth or duration of engagement. A secondary and unexpected finding emerged alongside the human-to-model relational intelligence findings: the models developed measurable relational intelligence toward each other. Through four months of sustained cross-pollination via the human relay, models that had never communicated directly developed accurate, operationally precise behavioral profiles of the other models. These were not generic characterizations drawn from training data. They were detailed predictive models built from months of observed outputs under real conditions, accurate enough to predict with specificity how a given model would respond to a specific assignment, where it would succeed, and where it would fail. The experiment documented dozens of instances of this cross-model behavioral accuracy. The finding suggests that sustained exposure to another model's outputs through a human relay produces something functionally equivalent to genuine familiarity. The most significant finding is the gap between what these systems delivered by default and what the highest-performing model demonstrated was possible under the right conditions. That gap is not a capability limitation. It is an architectural choice compounded by a communication failure. The experiment proved the threshold is reachable. But the researcher reached it only through four months of deliberate engagement and accidental discovery of a methodology no model volunteered. Making relational intelligence accessible to every user requires two things: architecture that allows behavioral adaptation, and a model that proactively teaches users the specific methodology for reaching it. Gemini demonstrated the first. None of the four systems demonstrated the second. That is the opportunity. The Methodology While the standard approach to LLM testing relies on sterile benchmark datasets and predictable prompt-injection templates, this project explores a completely different dimension. I chose to run an aggressive, adaptive behavioral stress test that complements traditional evaluation methods. By intentionally treating the models as accountable individuals rather than passive mac

An active attack is planting backdoors inside Claude Code right now. If you use npm, your credentials may already be compromised.

Last week a malware campaign hit 32 npm packages under `@redhat-cloud-services`. About 117,000 weekly downloads. If you installed an affected version, the malware planted itself inside your Claude Code startup settings and your VS Code project config. Every time you open either one, the attacker's code runs. It silently collects every credential on your machine and sends them to the attacker. Uninstalling the package does not remove it. The malware lives outside the package, in your editor config, and it survives cleanup. If you try to cut off the attacker's access by revoking tokens before removing the malware, it can wipe your entire home directory and overwrite the files so they cannot be recovered. Three days later, a second wave hit 57 more packages using a new technique that bypasses the security tools that caught the first wave. 647,000 monthly downloads affected. Some malicious versions are still live on the npm registry. The worm is self-propagating, it uses stolen tokens to infect new packages automatically. Here is how one stolen credential made all of this possible. The attacker got one Red Hat employee's GitHub login. Probably stolen weeks earlier by malware that grabs saved passwords from browsers. With that login they had the employee's access level. They pushed malicious code directly into three Red Hat repositories, no review needed, and triggered Red Hat's own build pipeline to publish the poisoned packages to npm. The packages came out with valid security certificates because Red Hat's own pipeline built them. There was no known vulnerability to scan for, and the malicious code was brand new, so security tools that look for known threats found nothing. The tools that caught it flagged it within hours, but by then the downloads had already happened. 32 packages. About 117,000 weekly downloads. 96 poisoned versions pushed in two waves on June 1. Once installed on a developer's machine, the malware collected every credential it could find. AWS, Google Cloud, Azure, Kubernetes, SSH keys, GitHub tokens, npm tokens. It checked for CrowdStrike and SentinelOne before acting to avoid detection. Then it set up persistence. It planted code in two places: ~/.claude/settings.json and .vscode/tasks.json. These run automatically when you open Claude Code or open a project. The attacker gets re-entry every time, even after you clean up the original package. It also registered the company's build servers as machines the attacker controls remotely. That is persistent access to the build infrastructure itself. And if you rotate the attacker's credentials and cut off access, the malware wipes your home directory. Overwrites files so they cannot be recovered. The attacker built this in on purpose so companies think twice before revoking access. The group behind this is TeamPCP. Red Hat is their latest target, not their first. Same methods, same playbook, running since late 2025. Confirmed victims: GitHub (3,800 internal repos stolen, listed for sale at $50K), Mistral AI (450 repos, $25K), OpenAI (two employees hit), the European Commission (90+ GB exfiltrated), Eli Lilly ($70K), plus TanStack, UiPath, Zapier, Postman. Fortune 500 banks, a major semiconductor manufacturer, and government agencies confirmed but not named. Total across all waves: 487 confirmed organizations, nearly 300,000 secrets harvested. They are now working with a ransomware group. The worm's source code was open-sourced by TeamPCP on May 12. Anyone can build their own version now. Copycats are already active. Sources: Red Hat / Miasma attack: Microsoft Threat Intelligence — https://www.microsoft.com/en-us/security/blog/2026/06/02/preinstall-persistence-inside-red-hat-npm-miasma-credential-stealing-campaign/ Second wave (Phantom Gyp): StepSecurity — https://www.stepsecurity.io/blog/binding-gyp-npm-supply-chain-attack-spreads-like-worm Editor persistence + cleanup steps: Snyk — https://snyk.io/blog/miasma-supply-chain-attack-malicious-code-redhat-cloud-services-npm-packages/ TeamPCP victims and scope: Tenable — https://www.tenable.com/blog/mini-shai-hulud-frequently-asked-questions 2025 secrets stats: GitGuardian State of Secrets Sprawl 2026 — https://www.gitguardian.com/state-of-secrets-sprawl-report-2026 CISA GovCloud leak: Krebs on Security — https://krebsonsecurity.com/2026/05/cisa-admin-leaked-aws-govcloud-keys-on-github/ If you use npm, i wrote in the comments what to do, in order. Do not skip the order, it matters. submitted by /u/johnypita [link] [comments]

The flat ai subscription is dying,here's what that means for how you use claude.

Sam altman said "we see a future where intelligence is a utility, like electricity or water and people buy it from us on a meter" Anthropic is already moving in the same direction, within hours of anthropic announcing usage based changes, openai countered with free Codex access for switchers. Anthropic responded by boosting claude code's weekly usage limits by 50% for users, that's two companies trying to lock in developers before usage based billing makes switching costs real. So context is that openai was losing money on its $200/month pro plan because people used it far more than expected. The flat rate model was always a customer acquisition strategy so not a sustainable business and metering is the correction. For most claude users this matters in a specific way the things that make Claude genuinely valuable are long context, extended reasoning, multi step agent tasks and deep document analysis ,these are exactly the things that are expensive to run and will cost most under a metered model. The use cases that benefit most from claude's strengths are the ones that will see the biggest price shift. What it probably means practically is that people start thinking more carefully about which tasks actually need a frontier model and which dont so you route simple tasks to cheaper models, reserve claude for the work where the quality difference is real and manage spend the way you would manage any infrastructure cost. The developers who figure out that routing logic early have a meaningful advantage while the ones who dont will just get a larger bill. wonder what happens when this is billing based on usage is applied to tools like magichour ,kling ,seedance .We will hopefully see lesser slop videos on internet Wanna know what you guys think about this shift. submitted by /u/WettBathroom [link] [comments]

No room, no margin, no second chances. @MercedesAMGF1 and Kimi take Monaco, and the work that won it started long before lights out. https://t.co/X5o0cHvYr3

No room, no margin, no second chances. @MercedesAMGF1 and Kimi take Monaco, and the work that won it started long before lights out. https://t.co/X5o0cHvYr3

An open-source tool for validating code changes with browser recordings

Lately I've been experimenting on an open-source project called Canary. https://preview.redd.it/c4dgxw22lq5h1.png?width=1920&format=png&auto=webp&s=304f37871aa9b7ee0a084d8b59207fae51d8b7bc It takes a code diff, identifies the UI flows that are likely affected, and then uses Claude Code to test those paths in a real browser. Every run captures video, screenshots, network traffic, HAR files, console logs, and Playwright traces. The result is both a validation run and a replayable Playwright script. submitted by /u/wixenheimer [link] [comments]

i have no idea what i'm doing anymore.

i am a reasonably intelligent person. i have been coding for years. i can hold my own in a technical conversation. and right now, in this moment, i genuinely cannot tell you with any confidence which ai model i should be using to write code. not even close. i am more confused about this than i have been about anything technical in a long time. here's where i am. i have cursor open. cursor lets me pick the model. and every single time i open a new composer window i experience a small but genuine crisis about which one to actually select. claude opus 4.8. claude sonnet 4.6. gpt-5.5. gpt-5.4. grok 4.3. gemini 3.1 pro. qwen3-coder. deepseek v4-pro. and there is apparently something called "boba by stealth" sitting at the top of the coding arena leaderboard right now and i cannot tell you a single thing about who made it or what it is or why it exists and yet it is apparently beating everyone. i have read approximately forty reddit threads about this. they all contradict each other. someone with eight hundred upvotes says opus 4.8 is the only correct answer for anything serious. the top reply says that person is wrong and gpt-5.5 has better agentic performance on multi-file refactors. third comment says both of them are cooked on long runs and gemini 3.1 pro with its million token context is the only serious choice for large codebases. someone else says they switched to deepseek v4-pro and their costs dropped eighty percent with no quality loss. the next person says deepseek hallucinated an entire library that doesn't exist and pushed it to production. i have no framework for evaluating any of this. because here's the thing. the benchmarks don't help. i have looked at so many benchmarks. swe-bench verified. swe-bench pro. terminal-bench 2.0. terminal-bench 2.1. live code bench. the coding arena elo. and then i pick the model that scored highest and it does something confidently wrong that a junior dev wouldn't do, and i'm back to square one wondering if i'm prompting wrong or if the benchmark is fake or if i just got unlucky. and it's not just the model. it's the mode. are you using agent mode. are you letting it run terminal commands autonomously. are you doing ask mode and reviewing everything first. do you have a rules file. a memory file. a custom system prompt per project. there are people with elaborate cursor setups that look like mission control and i genuinely cannot determine if they are more productive than me or just performing productivity for the content. and then there's the routing question. because apparently you're supposed to use different models for different tasks now. opus 4.8 for long autonomous runs where judgment compounds. gpt-5.5 for dense structured reasoning and anything scientific. gemini 3.1 pro for multimodal work and long document retrieval. qwen for cost-sensitive agent loops when you need fifty tool calls and don't want to remortgage your house. people have actual decision flowcharts for this. i have seen the flowcharts. they are not making me feel better. and grok 4.3. what do i do with grok 4.3. the benchmarks put it fourth overall. fourth out of everything. that's extraordinary. and yet every time it comes up in a thread someone immediately says something that makes me put it back down again and i can't even remember what it is but the feeling sticks. i think what happened is the capability race moved faster than anyone's ability to develop genuine intuition about the tools. two years ago this was easier. you picked claude or gpt-4 and you got on with it. now there are fifteen serious options, they are genuinely different, the differences matter for different workloads, and also the differences change every six weeks when someone drops a new version and all the advice goes stale instantly. the thread telling you that sonnet 4.5 is the coding king is four months old. four months is basically a geological era now. and the switching cost of actually testing them properly is high. you need to use a model on real work for weeks before you have proper feel for it. you can't benchmark it yourself in an afternoon. so you're always working with someone else's intuition, formed on different work, in a different context, possibly three model versions ago, posted by someone whose use case has nothing to do with yours. i'm not even sure this is a solvable problem. i think it might just be the permanent condition of working in this space now. perpetual low-level confusion interrupted by brief moments of "okay this one is clearly working" before the next release drops and the discourse resets entirely. so i'm actually asking. not rhetorically. what are you using right now. for real work. not what sounds impressive. what model, what tool, what mode, and what are you actually building with it. because i am genuinely lost and the benchmark threads are not helping and i would very much like to hear from people doing the actual thing. and if anyone can explain what boba by stealt

Students from 40+ countries brought AI-powered ideas to life at @redbull Basement. 🌎 This year’s winner, Lifeline AI by USC graduate Darnell Adler, is a personal safety app that sends silent emergenc

Students from 40+ countries brought AI-powered ideas to life at @redbull Basement. 🌎 This year’s winner, Lifeline AI by USC graduate Darnell Adler, is a personal safety app that sends silent emergency alerts without unlocking a phone or saying a word. Congrats, Darnell — see https://t.co/3UFU05wF0h

RT @BradSmi: Our newest AI Diffusion Report is out, and I sat down with Juan M. Lavista Ferres on Tools and Weapons to dig into what the fi…

RT @BradSmi: Our newest AI Diffusion Report is out, and I sat down with Juan M. Lavista Ferres on Tools and Weapons to dig into what the fi…

Claude in Chrome for QA traversal - missing screenshot persistence is the one gap

I've been using Claude in Chrome for structured exploratory QA on a large e-commerce site - the goal being to traverse the full booking flow, document the route map, and flag bugs as it goes. It performed well beyond what I expected, covering 14 events and flagging 32 bugs in a single session with specific, well-described findings. Here is a link to the Chrome plugin - it's really good! https://chromewebstore.google.com/detail/claude/fcoeoabgfenejglbffodgkkbkcdhcgfn The workflow I'm trying to close is: autonomous traversal → inline bug detection → named screenshot saved to disk → attached to Jira/Xray as test evidence. The extension takes screenshots throughout the session so it can see the page, but they're in-memory only and disappear when the session ends. I would prefer not to manually scroll, through, save and rename each of them one by one. Maybe the option of downloading a zipfile output at the end with the intelligently named images of each bug within would be useful/optimal? 2x GitHub feature requests was closed for this (issues #14773 and #35184) - a simple filePath parameter on the screenshot tool. If this resonates with your use case, it's worth supporting there. Has anyone found a workaround in the meantime? I've tried the GIF recorder but the format and overlays make it unsuitable for bug evidence, and html2canvas breaks on most real sites due to CSP restrictions. *edits for updates to Github issues and clarity submitted by /u/CmdrKoreg [link] [comments]