Category: AI & Open Source

  • bunny.net Reissues TLS Certificates After Server Intrusion

    bunny.net Reissues TLS Certificates After Server Intrusion

    bunny.net isolated a CDN node in Armenia and began sequentially reissuing TLS certificates to address potential exposure following unauthorized access to third-party server-management software at an infrastructure provider. The company halted traffic routing to the affected server within 20 minutes of receiving the warning, then proceeded to delete server data and revoke access permissions. Investigations by both parties found no evidence of unauthorized access to bunny.net servers or data, but the circumstances make it difficult to conclude definitively that no incident occurred.

    Attack Surface Exposed at the Supply Chain Boundary

    Only one of bunny.net’s infrastructure providers reported the unauthorized access. According to the initial notice, a warning concerning access to third-party server-management software was received the week before. The affected server hosted one CDN node in Armenia. After receiving the warning, bunny.net’s engineering team halted traffic routing within 20 minutes, safely deleted the server data, and revoked access permissions to other systems.

    The impact of the CDN security incident depends on the assets stored on the server. If the node was accessed, temporarily cached CDN content, Pull Zone configurations, and TLS certificates stored on the server may have been exposed. Other customers’ data and bunny.net account data were not stored on the affected server, and internal systems were not impacted. bunny.net continues to monitor its infrastructure closely alongside the provider and pursue the investigation.

    Certificate Replacement and Different Customer Responses

    As a preventative measure, bunny.net revoked and reissued all TLS certificates for the platform domains b-cdn.net and bunny.run. Managed certificates for custom domains are also being replaced, with the process proceeding gradually in controlled batches to prevent interruptions to content delivery. New certificates use new private keys, while existing certificates will continue to be served without interruption until they are replaced.

    The work was initially expected to be completed within 24 hours, but a later update indicated that it would take longer than anticipated and finish by the end of October 31. Customers using managed certificates do not need to take any additional action. Conversely, customers who directly manage their TLS certificates are advised to revoke their existing certificates as a preventative measure and reissue them with new private keys.

    Supply Chain Security in Response to Access Risks

    The key aspect of this response went beyond disconnecting a single CDN node to also recovering adjacent assets, including certificates and permissions. The absence of evidence in the investigation does not amount to a definitive denial of a breach. It highlights the risk that when management software is compromised in a supply chain, stored configurations and cryptographic credentials can simultaneously become part of the attack surface.

    An additional update will be posted on the status page when certificate reissuance is complete, and customers will also be notified by email if any new facts affecting them are confirmed. Operators reviewing the bunny.net security incident should first examine their own TLS certificate management practices and, if they directly manage certificates, replace them with new certificates that do not reuse old keys. The full sequence of events is covered in the Bunny CDN security incident report.

    Source

    This article was prepared after reviewing the following source: geeknews — Bunny CDN security incident

  • korea-data-mcp Stops AI Agents Misreading Korean APIs

    korea-data-mcp Stops AI Agents Misreading Korean APIs

    korea-data-mcp for AI agents has been released. The project combines the DART, Public Data Portal, and National Law Information APIs into a single MCP server to help agents such as Claude and Cursor accurately retrieve Korean company, real estate, and legal data.

    Misreading Pitfalls Hidden in Public API Responses

    Even when public API responses are passed directly to AI agents, they may appear plausible while producing incorrect answers. A representative example is a DART semiannual report. When asked about Samsung Electronics’ revenue for the first half of 2025, an agent may respond with KRW 74.6 trillion because thstrm_amount covers three months in the second quarter rather than the first-half cumulative total. Actual first-half cumulative revenue is listed as KRW 153.7 trillion.

    korea-data-mcp addresses these issues at the server level and currently handles 47 pitfalls. For legal information, it corrects cases where amendments to existing laws that have not yet taken effect are mixed into the body of the current statute. It selects the version in force on the reference date and displays provisions scheduled to take effect along with their effective dates.

    For actual apartment transaction prices, it prevents canceled contracts from being included as valid transactions. By default, it calculates the median after excluding the canceled contract. It also addresses the problem of receiving zero results for the previous month when an outdated regional code is entered due to administrative district restructuring, and provides the updated code. Other input errors, amounts in units of KRW 10,000, and dates with two-digit years are also handled separately. The complete list is documented in the repository’s docs/QUIRKS.ko.md file.

    Local Execution and Data Coverage

    Supported areas include DART company, disclosure, and financial statement data, stock prices, basic company information, business registration status, actual apartment sale and purchase prices, public holidays, laws, and court precedents. On Claude Desktop, it can be installed by opening the included.mcpb release file, and it is also registered in the official MCP Registry. Other environments support either a single Go binary or a go install method.

    Users provide their own free API keys. A single OpenDART key is enough to get started within a few minutes. The server runs only on the user’s personal computer and does not use third-party servers or telemetry. A hosted version that can be accessed through a URL without requiring a key is being prepared.

    korea-data-mcp takes the concept of connecting Korean public APIs to AI agents a step further. Instead of displaying raw responses, the server filters out conditions that can produce incorrect answers, such as reporting periods, contract status, administrative districts, and the effective dates of laws. The developers are considering sources such as the Bank of Korea’s ECOS and KOSIS, and are seeking related feedback. More details are available in the GitHub repository.

    Reference Sources

    This article was written after consulting the following source: geeknews — Show GN: korea-data-mcp – An MCP server that helps AI agents correctly read Korean public APIs

  • Context Engineering for Agents: Strategic Forgetting

    Context Engineering for Agents: Strategic Forgetting

    Reduced to a single sentence, the factor that determines the performance of an AI agent is closer to context engineering than the model itself: selecting and delivering the information needed for the current goal. Dividing responsibilities between deterministic code and probabilistic models, and periodically discarding outdated state, are emerging as alternatives that compensate for the limitations of long context.

    Four Failures Created by Long Context

    Long context windows hold not only more information, but also hallucinations, incorrect facts, and conflicting examples. The resulting failures include context contamination, in which the model fixates on incorrect information; attention dilution caused by excessive focus on the context; confusion, in which facts unrelated to the current problem influence the answer; and context collisions, where tools and skills unexpectedly conflict.

    In Gemini 2.5’s Pokémon playing experiment, older game rules and newer tasks were presented together, causing the model to pursue outdated goals for several hours. According to an appendix in a technical report, once the context considerably exceeded 100,000 tokens, the model began repeating past actions instead of creating a new plan.

    In Carolina Camassa and Derek Shiller’s “Do as I Say, Not as I Do” experiment, adherence to original instructions declined across every tested model as the number of conversational examples conflicting with new instructions increased. Gemma 3 12B dropped to less than half its compliance rate with only a few conflicting examples, and Opus 4.6 showed the same problem as examples accumulated.

    Six Techniques for Context Management, from Augmentation to Summarization

    Context management includes enriching information with RAG and skills, as well as selecting tools to expose only those suited to a request, preventing overload. One company loaded 600 skills for each engineer whenever a software project began, causing an abrupt decline in performance and making tool filtering necessary. Context isolation starts subagents and peer agents with an empty conversation history, separating information and goals from other tasks.

    Other techniques include pruning outdated history, external storage that keeps information in Markdown files or databases, and summarization, which condenses older conversations to begin a new context. Claude Code and Codex also removed tool results that had become unnecessary during the initial stages of context compression. In practice, evaluating relevance first and then reducing history before summarizing can produce more useful compression results.

    Moving Context Construction into the Harness

    Context engineering evolved from prompts that dynamically assemble system context into harness engineering, which moves processing into code outside the context. A DSPy demonstration combined a ReAct module and Python function tools in a while loop to accumulate conversation history.

    Tool selection used the large model Claude Sonnet 4.5 together with the smaller judgment model Jev. Jev evaluates requests and tools, selects the necessary tool set, isolates subagents, and reviews each conversation turn to remove unnecessary history. The change that incorporated these four improvements into a single loop was introduced in roughly 16 lines.

    Failures in Long-Running Tasks and Strategic Forgetting

    Long-running task models have introduced new problems: a “fight with the weights,” where learned behavior conflicts with current instructions, and “context inertia,” in which the model continues pursuing hypotheses and subgoals that should be abandoned. Claude Code’s system prompt and tool instructions repeatedly requested parallel execution of independent tool calls, revealing a behavioral bias in the Learning environment.

    The Memento harness used in Anthropic’s self-replication research mitigated fixation by writing brief notes and clearing the context every 90 minutes. It preserved the environment and task results while discarding the ongoing conversation, allowing the agent to restart from a new perspective. Microsoft Research’s Fork-and-Flush addressed the problem of exploration stalling after major improvements, while UC Berkeley’s Scaling Discovery Requires Forgetting, led by Shangyin Tan, reported that performance rose again when the context was periodically cleared while retaining outputs.

    For personal agents, memories and skills accumulate over time, and conflicting instructions are likely to become a new operational challenge. During six months of operating Hermes, unusual modifications accumulated in skills and could worsen problem-solving behavior; a general-purpose agent also faced conflicts between memories and instructions as it solved the same problem in different ways. Existing techniques such as isolation, external storage, and deleting accumulated history remain the available responses. The quality of an agent harness depends less on the size of the context window than on how precisely it automates goal-oriented information selection and strategic forgetting.

    This shift can be observed in material on the current state of context engineering. Teams designing long-running agents must consider not only prompt length, but also what to retain in the context and when to clear it.

    Original Source

    This article was prepared after reviewing the following original source: geeknews — The Current State of Context Engineering

  • LLM Formal Verification: Claude Verifies 123 Libraries

    LLM Formal Verification: Claude Verifies 123 Libraries

    Anthropic and Theorem used Claude to formally verify 123 open-source libraries targeted by Google OSS-Fuzz, covering 239 fuzzing entry points at the binary level. After fixing the bugs, they expanded the verification to prove that the compiled code would not crash under specified execution environments and input-size conditions. This experiment demonstrated both the scale and reusability of LLM-based formal verification, while revealing that defining the boundaries of its guarantees remains a central issue.

    Turning Fuzz Tests into Code That Never Crashes

    Formal verification translates code into a mathematical model and demonstrates that it does not violate defined rules. Conventional tests check whether specific inputs pass or fail, but they do not guarantee that every code path will be explored, even when execution time is increased. This experiment transformed fuzz tests, which developers design to generate inputs that expose crashes, into a specification requiring that the code not crash with any input below 64MB.

    After compiling the libraries and fuzz tests as RISC-V executables, Theorem modeled the behavior of the actual binaries using its formalizations of RISC-V instructions and Linux process semantics. Claude was used to handle large-scale proofs covering the possible behavior and interactions of tens of thousands of instructions, while the Rocq code it produced allowed the kernel to check whether the specification had been satisfied. Using AddressSanitizer to expose invalid memory accesses as crashes provided the foundation for memory-safety specifications.

    Bugs Revealed at the Boundaries Missed by Fuzzing

    During the proof process, Claude immediately patched the bugs it found, regenerated the specifications, and continued its work, confirming hundreds of bugs. A counter underflow in decompression code caused an out-of-bounds write in a rare arrangement of inputs of approximately 20MB, while an out-of-bounds read in an image decoder required a 64MB input and more than 2GB of memory. In another library, an out-of-bounds read occurred only when two handles to the same file were used in a specific call order.

    Claude also rediscovered CVE-2026-56132 in libexpat, which required deeply nested inputs. Even in tasks that ultimately failed to produce a successful proof, the proof attempts helped identify bugs that required actual fixes. This shows that the failure of formal verification does not necessarily mean the conclusion must be discarded; instead, it can identify areas that require further investigation and patching.

    The Trust Boundary of Machine Checking and Proof Reuse

    The full proof consisted of approximately 180 million lines of Rocq code, far larger than the roughly 600,000 lines typically required for an ordinary proof. Although humans do not need to review every line of such a massive proof, its guarantees depend on the assumptions that the target is a single-threaded static binary and that it executes on a Linux system with a RISC-V CPU. It is still necessary to confirm that the formal models of RISC-V and Linux processes accurately reflect reality and that the statements of the proven theorems are correct.

    Because proof generation requires an enormous number of tokens, reducing costs also emerged as a central challenge. Across 36 small verification tasks created from OSS-Fuzz code, Opus 5.5 proved half of the tasks using approximately 40% fewer tokens than Opus 5. A shared workspace that allowed agents to copy one another’s proofs reduced token usage by 17% and enabled some tasks to succeed that had failed when attempted independently. Recursively combining common code with smaller proofs was presented as a key strategy for improving the scalability of LLM-based formal verification.

    Conditional Proofs Rather Than a Guarantee of No Bugs

    The verification target was a single-threaded static RISC-V binary linked with musl libc. Since real-world deployment environments generally use binaries dynamically linked with glibc on x86 or ARM, verification would require a system model closer to the deployment environment and accurate x86 semantics. ASan also fails to detect every memory-safety bug, and verifying every entry point does not guarantee the entire library, including code that is unreachable.

    Formally verified does not mean bug-free. A checker can determine only whether a formal specification has been satisfied; it cannot judge whether that specification accurately reflects reality. Problems outside the guarantees may remain if callers misuse public functions or if execution conditions not covered by the specification exist. The significance of this experiment does not lie in the claim that AI can provide complete and correct answers for all software. Instead, it lies in expanding machine-checkable guarantees to cover testable properties while making their scope and trust boundaries equally clear.

    The experiment’s summary and additional background can be found in coverage of LLM-based formal verification.

    Source

    This article was written based on the following source: geeknews — LLMs are making much larger-scale software formal verification possible

  • GPT-Rosalind and Claude Usher In AI Science’s New Roles

    GPT-Rosalind and Claude Usher In AI Science’s New Roles

    OpenAI and Anthropic unveiled their AI-assisted biology research one day apart. OpenAI’s GPT-Rosalind ran 1,946 AI agents in parallel, analyzing large-scale genetic experiment data from mouse brain cells in 32 minutes, while Anthropic’s Claude demonstrated an approach of designing protein candidates that bind to scorpion neurotoxins and then validating them through experiments. Both cases show that AI science is rapidly gaining ground in the exploratory stages of hypothesis generation and candidate design.

    Parallel Analysis and Large-Scale Candidate Design

    GPT-Rosalind rediscovered or refined 48 of the 55 findings identified in previous research. Having multiple agents analyze existing experimental data simultaneously broadened the scope of exploration through which researchers can derive new hypotheses from accumulated materials. According to OpenAI, the system generated new biological hypotheses based on existing experimental data.

    Claude’s case focused on design and selection beyond the generation stage. Anthropic used AI to design 318,484 candidates for binding scorpion neurotoxins, then tested 211 in actual experiments, 17 of which met strict binding criteria. The crucial element is the setup in which AI-designed proteins are validated in a laboratory.

    Experiments Remain the Bottleneck After Hypothesis Generation

    The significance is that AI science is beginning to take on the role of generating and screening vast numbers of hypotheses and candidates, rather than entering a stage where it replaces the entire process of scientific discovery. The speed of producing candidates has increased, but the experiments and validation needed to connect them to genuine scientific discoveries or therapeutics remain a bottleneck.

    In this structure, the researcher’s role focuses on turning the vast quantity of AI-generated exploration into testable scientific claims. The scale and reproducibility of exploration are strengths of AI science, but the criteria that determine a candidate’s reliability and usability are still established through experiments. The original article summarizing the two research announcements presents two examples of AI science that approached the field in different ways.

  • Harness² Boosts AI Agents Without Changing Models

    Harness² Boosts AI Agents Without Changing Models

    Google Cloud AI Research has introduced Harness², a recursive framework that improves an agent’s execution environment without replacing the agent’s model. The framework refines the code and files surrounding a frozen model, taking an approach aimed at improving agent performance without relying on a better model. The released version is 0.1.0, with no learned parameters and eight editable harness components provided as files.

    Changing the Environment Around the Agent, Not the Model

    In Harness², the harness is a broader concept than the model itself. Prompts, tools, memory, skills, and orchestration are all included in the system surrounding the model, and optimizing this environment is what is known as harnessing. Model weights remain unchanged, and the framework is designed to improve an agent’s harness during actual deployment.

    The harness has eight editable components, each mounted as a file. These components cover context construction, tool interfaces, delegation, and behavior within tool loops. In other words, Harness² is designed for open-ended environments without a validator that provides the correct answer, rather than closed environments where the answer is supplied. Unlike many self-improvement methods that rely on labels or test cases, the framework is designed to operate without such indicators.

    Propose·Probe·Compose Verifies Failures Through Behavioral Differences

    The core of Harness² consists of two connected stages: task-level recursion and harness-level recursion. Task-level recursion uses a contrastive Propose·Probe·Compose procedure. It first runs a task with a baseline harness, after which the editor proposes candidates, compares them on the same task, and retains only the edits supported by observed behavior.

    The candidates proposed by the editor include invariant candidates that target common agent failures and domain candidates that address the knowledge and procedures of the current domain. The composer compares the baseline run with the trajectories of the two candidates, accepting only edits that produce a real behavioral difference rather than merely appearing to solve the task better. This approach focuses on the differences in behavior produced by candidates as direct evidence that replaces answer labels.

    After the task is processed, the reflection stage saves the adopted harness and the lesson document, EXPERIENCE.md. This experience library is used in later proposals, but each new task starts again from the default harness. Parallel mode explores k invariant candidates and k domain candidates, then combines them k times, while sequential mode chains k improvement stages. As the exploration breadth increases, the number of additional model executions and the cost per task also increase.

    Performance and Execution Costs Across Three Benchmarks

    The implementation targets Linux, Python 3.12 or 3.13, and uv, using Vertex AI for model execution. GPU requirements have not been disclosed. Model-based execution requires Node.js 20 or later, Google Cloud CLI, and a Vertex AI project, while LAB requires Pandoc and Poppler, and WorkBuddy-Bench requires Docker. OpenCode is the default runner, with Codex available as a separate option.

    Evaluation used three specialized benchmarks: WorkBuddy-Bench, JobBench, and Harvey’s LAB. The execution models were Gemini 3.5 Flash and GLM-5, the execution environments were OpenCode and Codex, and the default editor was Claude Opus 4.8. Results are presented as the average of three runs. One improvement stage raised performance across all four model-and-harness combinations and all three benchmarks, although the size of the improvement varied by environment.

    On WorkBuddy-Bench, GLM-5 using OpenCode rose from 64.2 points to 75.7 points, an increase of 11.5 points. The Gemini and OpenCode combination with k set to 5 for parallel recursion recorded 80.8 points on the same benchmark. The number of stages per task also decreased: three of the four WorkBuddy-Bench combinations required fewer stages, while Gemini and OpenCode fell from 25.4 stages to 21.9. By contrast, the smallest improvement for GLM-5 using Codex on JobBench was only 1.2 points, rising from 23.6 to 24.8.

    Practical Requirements for Harness Optimization and Validation Challenges

    The value of Harness² lies in rewriting the harness at test time without training a model. However, because it requires additional executions, cost forecasting and execution isolation are needed together. Since external commands operate through the tool interface, sandboxing must also be configured directly. The Harness² release report quoting the original source introduced the performance figures, but the exact detailed configuration and reproduction conditions must be checked in the paper and repository together.

    The change presented by this framework is not to introduce a larger model immediately, but to correct the planning and tool use of an already deployed agent during execution. Propose·Probe·Compose judges the superiority of candidates through behavioral differences rather than an answer key, while EXPERIENCE.md connects adopted lessons to proposals for subsequent tasks. The key point is that harness optimization is becoming an execution strategy that requires not only performance improvements, but also attention to model-call counts, isolated environments, and reproducible evaluation design.

    Source

    This article was prepared after consulting the following source: MarkTechPost — Google Open-Sources Harness2, a Recursive Agent Harnessing Framework

  • DeepSeek Unveils V4.1-Flash-1017 and Web Search APIs

    DeepSeek Unveils V4.1-Flash-1017 and Web Search APIs

    DeepSeek has released the DeepSeek-V4.1-Flash-1017 model and made it available on its website, in its apps, and through the API as the deepseek-flash model. The new model is a follow-up checkpoint to September’s V4.1-Flash and, according to DeepSeek’s own measurements, achieved leading performance across 11 benchmarks. At the same time, the company opened its Search API and Fetch API to all developers, allowing the model and web information access layer to be configured with a single API key.

    What the 77.0 DeepSWE Score Means for Coding

    DeepSeek said the 1017 checkpoint scored between 2.0 and 11.1 points higher than the previous V4.1-Flash across 11 benchmarks. It recorded a score of 77.0 on DeepSWE v1.1, surpassing the previous V4.1-Flash’s 74.2 and Claude Opus 5’s 74.0. It also posted 60.5 on Automation-Bench and 35.4 on Agents’ Last Exam, leading in those categories as well.

    However, the performance advantage does not extend to every area. The 1017 checkpoint scored 42.6 on HLE without tools, below Claude Opus 5’s 56.3, while Claude Opus 5 also led on Terminal-Bench 4.0, ProgramBench, and NL2Repo. These figures were measured by DeepSeek itself and should be treated as performance claims that require independent verification.

    Model DeepSWE v1.1 HLE without tools
    DeepSeek-V4.1-Flash-1017 77.0 42.6
    DeepSeek-V4.1-Flash 74.2 Not reported
    Claude Opus 5 74.0 56.3

    MoE Architecture and Long-Context Efficiency

    DeepSeek-V4.1-Flash-1017 is based on a multimodal Mixture-of-Experts model that divides 40 Transformer layers into 20 causal encoders and 20 decoders. It has a total size of 552B backbone parameters and 196B Engram parameters, with 8B active parameters for prefill and 16B for decoding on a per-token basis. It supports a maximum context of 1M tokens and output of up to 384K tokens.

    Efficiency features include Causal Encoder-Decoder, Compressed Sparse Attention 2, an FP4 main KV cache, and SWA Bounded Replay. CED projects the decoder’s global KV from the final encoder hidden state, reducing prefill computation by nearly half. CSA2 operates layers in Full, Reindex, and Reuse modes while sharing main KV and indexer keys across layers. The FP4 main KV cache reduces global KV to 890 bytes per token, about one-quarter the level of V4-Flash, while SWA Bounded Replay reduces the persistent KV cache to roughly one-eighth.

    Post-training applied reinforcement learning with self-feedback, and end-to-end project work examples included game development and 3D modeling. The API’s reasoning effort is a scalar from 1 to 100, with low, high, and max corresponding to 50, 75, and 100, respectively.

    Simplifying Web Access with the Search and Fetch APIs

    The Search API returns ranked web search results for queries, while the Fetch API converts a single page into Markdown. Their endpoints are POST /v1/tools/search and POST /v1/tools/fetch, respectively, and both are available through api.deepseek.com. The Search API supports between 1 and 50 results, optional page content, and the site:, lang:, after:, and before: operators. Each result includes a rerank score from 0 to 3 and an authority tier from 0 to 4.

    Pricing and limits are the same for both APIs. The Search API and Fetch API each cost $0.75 per 1,000 successful requests, with no charge for empty results or failed requests. Each account is limited to 5 endpoint requests per second.

    Remaining Constraints on Cost and Open Weights

    The peak price for deepseek-flash is $0.30 per 1M uncached input tokens and $1.20 per 1M output tokens, while off-peak rates are half those amounts. Server-side calls through DeepSeek Harness, Claude Code, and Codex are free until November 1, 2026. The model can be called through OpenAI-compatible and Anthropic-compatible endpoints.

    The 763B-parameter FP8 weights for September’s V4.1-Flash were released on Hugging Face under the MIT license. However, the weights and hardware requirements for the 1017 checkpoint have not been released. Because the company provides the API service alongside web tools, practical selection requires comparing coding quality, long-context throughput, invocation costs, and self-hosting availability. More details are available in MarkTechPost’s public report.

    Source

    This article was prepared by consulting the following source: MarkTechPost — DeepSeek Just Released V4.1-Flash-1017, Scores 77.0 on DeepSWE, Opens Search API

  • Kubernetes AI Agents Cut Idle Resources With Snapshots

    Kubernetes AI Agents Cut Idle Resources With Snapshots

    This infrastructure tool runs multiple AI agents in isolated sandboxes while reclaiming resources left idle during waiting periods. It saves memory and file state while waiting for model responses or tool execution, then restores that state and resumes work when a request arrives. Its goal is to reduce the cost of always-running Kubernetes workloads while maintaining AI agent isolation.

    A microVM architecture that supports Pod reuse

    Agent Substrate has a small pool of preprepared Kubernetes Pods that multiple agents take turns using. It isolates execution environments with microVMs based on gVisor or Cloud Hypervisor, but does not support running agents in standard Linux containers alone. Because it can use standard OCI container images, it is not tied to specific models or agent SDKs.

    Saved state can be restored on another worker, preserving sessions and working environments even when execution moves to a different location. This architecture addresses the Kubernetes resource management challenges of maintaining a Pod for each agent and leaving resources idle for extended periods through state saving and restoration.

    External requests protected by gateways and policies

    API keys and credentials are managed outside the sandbox, and a gateway injects them only into permitted external requests. The system can also distinguish agent identities, separate network access, and integrate with policies for external authentication and data exfiltration prevention. As a result, AI agent isolation covers not only the execution environment but also authentication boundaries and data movement policies.

    Kubernetes deployment and remaining operational requirements

    Agent Substrate deploys directly to Kubernetes and requires PostgreSQL and a snapshot store. It also provides local kind and GKE development environments. Before production adoption, teams should validate microVM isolation, snapshot restoration, worker migration, and credential injection boundaries together. These details can be confirmed in the original Agent Substrate information.

    Source

    This article was prepared with reference to the following source: geeknews — Agent Substrate – A Kubernetes runtime that isolates AI agents and reduces idle resources

  • Dekton Material Science: From Porcelain to Body Supports

    Dekton Material Science: From Porcelain to Body Supports

    Dekton, developed by the Spanish company Cosentino in 2013, is essentially porcelain made with advanced manufacturing processes. Its high resistance to heat, pressure, scratches, fractures, and stains has made it a surface material of choice for countertops, while related materials and applications are expanding into artificial joints and bone regeneration.

    A Question That Began with an Expensive Induction Cooktop

    When a couple bought a high-end induction cooktop, it did not include a cooking surface that could be placed over the burner; that surface had to be purchased from a separate company. The website did not make this clear, and instead of the tempered glass, which cost about $30 per square foot, it required Dekton, a material five times more expensive.

    Such stories raise the question of why an unfamiliar material is so expensive. Dekton is an advanced substance that was difficult to manufacture about 30 years ago, but its origins lie in humanity’s 3,000-year-old use of porcelain. Porcelain was a technological leap that combined an ancient base material resembling clay plates with knowledge of kilns and chemistry.

    When Porcelain’s Crystals Changed

    Porcelain makers in northern China experimented with kaolin and found the starting point for porcelain production. Kaolin, which looks like ordinary clay, consists of plate-like microcrystals bonded by water. When heated, the water escapes and the needle-shaped crystals interlock firmly.

    Kaolin is rich in kaolinite. At approximately 1,200°C, aluminum and oxygen form silica, while liquid glass fills the spaces inside and outside the crystal network. This process creates a dense, continuous, translucent porcelain structure.

    Kiln technology was also essential to porcelain production. Chinese makers used a downward-draft ventilation structure that allowed hot air to escape through the floor, and they developed refractory bricks that would not crack or melt at high temperatures.

    From White Gold to Meissen

    Europe encountered East Asian porcelain around the 13th century and considered a material that was both strong and smoothly glossy to be “white gold”. However, Europeans did not understand the roles of kaolin and China stone, and even maiolica, faience, and Delftware made with cassiterite and glass powder lacked porcelain’s true impermeability and high tensile strength.

    Ehrenfried Walther von Tschirnhaus explored porcelain production by heating minerals with a collecting lens. Between 1693 and the winter of 1694, he discovered that the clay from Colditz did not melt. Between August and September 1708, he mixed powdered limestone with white clay rich in kaolin to make vessels resembling Chinese porcelain.

    After Tschirnhaus died, Johann Friedrich Böttger took over the manufacturing method, while Augustus the Strong established the Meissen Royal Porcelain Manufactory in 1710 and placed it under his supervision. Meissen products were stronger and less porous than their Asian counterparts, and over the following decade or so, its workers learned that local stone, called China clay, was a valuable additive.

    The Porcelain Weaknesses Dekton Reduced

    Developing Dekton required six years and about $200 million. A slurry of ground porcelain, glass, and quartz is baked into a sheet, after which a large hydraulic press applies a compressive force of 250,000 metric tons. It is then cured at approximately 1,200°C.

    The tiny gaps and defects in traditional ceramics act as stress concentrators that collect impact energy in one place. The high temperatures and pressures used in Dekton production promote atomic diffusion at the contact boundaries between kaolinite and quartz particles, binding the material together as a single solid and reducing brittleness and structural weakness.

    Wet Tiles and Ceramics Inside the Human Body

    Methods that activate only when wet have also been applied to anti-slip tiles. About a decade ago, Ceramica Sant’Agostino and Inalco, companies in Italy and Spain, introduced wet-activated or in-out tiles with special crystalline compounds baked onto their surfaces. When someone steps on a wet tile, pressure forces water into numerous pores, creating a suction effect between the foot and the tile and reducing slip.

    Instead of permanently replacing defective bones with 3D-printed bioceramics, researchers have created porous scaffolds that allow blood vessels and bone cells to move inside them. Over time, the structure dissolves and is replaced by the patient’s own tissue. In this way, interest in Dekton material science is expanding into physical technologies that connect countertops, bathroom tiles, artificial joints, and bone regeneration.

    Source Article

    This article was prepared after consulting the following original source: geeknews — What Exactly Is Dekton?

  • Using AI to Reverse Engineer Hardware on Linux

    Using AI to Reverse Engineer Hardware on Linux

    Developers working with poorly documented hardware must observe how vendor drivers behave correctly while identifying differences in their own implementations. In a case study using Claude Code, a film scanner driver was developed through a Windows virtual machine and Linux USB captures, while brightness and color issues in a laptop MIPI camera were also improved. The value of hardware reverse engineering lies not in speculating about vague principles, but in rapidly carrying out iterative traffic analysis and patch work.

    Creating Comparable Reference Behavior

    Development on the Plustek OpticFilm 8200i had been stalled for months because it was unsupported on Linux. But after recording USB data while running successful scans on Windows, the first Linux scan succeeded within hours. By the time an almost completed driver had been created, another developer had already added support for the scanner to SANE.

    The publicly released hw-harness is a project that organizes the custom code used in this experiment for easy reuse. The code used in the actual project was not exactly identical to the public version, and not all three tasks were performed through the released harness.

    What matters in hardware reverse engineering is not merely collecting large numbers of captures, but creating comparable runs. The physical device is passed through to a KVM Windows virtual machine, where a reference operation is performed with the Windows vendor driver. USB traffic beneath the passthrough layer is then recorded using usbmon on the Linux host, and the same operation is performed with the native Linux driver and captured again with the same tools.

    Directly comparing the two execution traces reveals repeated sequences that differ by even a single byte, as well as differences in initialization order. Such differences provide evidence that turns vague “it does not work” behavior into a list of actionable driver bugs. AI was well suited to repetitive work such as finding patterns across thousands of lines of captured data, estimating the meaning of constants, and writing tests for verification. Humans remained responsible for deciding what functionality to implement and determining whether it behaved correctly on the actual device.

    Film Scanning and Non-Destructive Post-Processing

    The scanner backend uses a Genesys GL128 controller and the USB identifier 07b3:1825, with support for color, grayscale, infrared, and combined color and infrared modes. It can scan at 300 to 7200dpi with either 8-bit or 16-bit data per channel, while the infrared channel is used to remove dust and scratches. The Fedora RPM package was released to build automatically with every push.

    After the upstream SANE genesys backend began supporting this scanner in September 2026, the two drivers were compared. At 3600dpi, they produced similar fine-detail levels, but scans at the maximum resolution took 34.6 seconds with the custom backend and 54.4 seconds with the upstream implementation. Because these results came from a single case involving one device and one frame, they should not be generalized to all performance conditions. The custom project is largely a proof of concept, and the upstream implementation is expected to be used once it reaches the same level of functionality.

    Negative Vibes Preserves the Original Data

    Negative Vibes is a GNOME application written in Rust that supports color and black-and-white negative scanning as well as slide scanning. It preserves the 16-bit linear data and infrared plane delivered by the scanner, accumulating post-processing settings so that the rendering can later be changed or re-exported. It provides negative inversion using an optical density space, crosstalk correction between the film base and dyes, and re-rendering for both entire film rolls and individual frames.

    The application supports both infrared and software-based dust removal, along with IT8 calibration through ArgyllCMS. It can export TIFF, JPEG, PNG, and DNG files with ICC profiles and metadata, and is distributed as a Flatpak that includes the scanner backend. However, supporting every SANE film scanner would require the infrared channel to be exposed through a standard mechanism, and no such standard currently exists.

    Expanding the Scope to MIPI Cameras

    The same harness was also used to modify the MIPI camera in a Lenovo ThinkPad X1 Carbon Gen 14 Aura Edition. The laptop combines an Intel IPU7 with a Sony IMX471 sensor, and its images appeared dark on Linux, with reduced peripheral light and a strong yellow-green cast. Because the internal camera was difficult to capture directly, its baseline values were obtained by examining the Windows INF file, registry data, ACPI tables, and device properties.

    The kernel driver fixes included an incorrect crop selection, an incorrect test-pattern register width, and an excessively low upper limit for analog gain. These changes resolved an issue that had caused the full pixel array to be used incorrectly and reduced the sensitivity loss of roughly 1.8 stops. In libcamera, lens shading correction was added, and the calculation that applied an 8-bit black level to white-balance statistics was corrected.

    Metric Before After
    Frame brightness 31.1 90.9
    Red-to-green ratio 0.890 1.047
    Blue-to-green ratio 0.672 0.823

    In a controlled low-light test, the modified camera produced color ratios closer to those of the reference USB webcam, although blue remained approximately 17% low. The original article attributes this to gray-world white balance. This case demonstrates the importance of configuration data and reference-camera comparisons even for devices whose buses are difficult to record directly.

    AI Development with Real-Hardware Validation

    In this case, AI focused on highly repetitive tasks such as decoding captures, writing verification code, and cross-checking constants. Developers remained responsible for choosing what to implement and determining whether the results were correct on the actual scanner and laptop. Hardware reverse engineering can therefore be seen not as a process that ends with AI speculation, but as an iterative process that creates captures and reference data, then validates them on physical devices.

    The results are not complete. The scanner produced visually acceptable film scans, and the camera was substantially improved, but additional tuning and refinement remain. The practical value of an AI agent does not lie in explaining every principle inside a device. Its value lies in rapidly narrowing the gap between correct and incorrect behavior, then validating those hypotheses through driver code and results from real equipment.

    Source

    This article was written after consulting the following source: geeknews — Reverse Engineering Hardware with AI