RSS Feeds

Far-right senator and his family boarded private plane to Ecuador after crossing border to Argentina, Argentina’s government confirms

The far-right senator Flávio Bolsonaro has reportedly fled Brazil and is on his way to the United States after losing Sunday’s presidential election to the leftwing incumbent, Luiz Inácio Lula da Silva, who called the act “shameful”.

A report by the news website Metrópoles, citing people close to the politician’s family, said he was en route to the US. “The plane is in flight,” Metrópoles reported, without making clear where it had departed from.

Far-right senator and his family boarded private plane to Ecuador after crossing border to Argentina, Argentina’s government confirms

The far-right senator Flávio Bolsonaro has reportedly fled Brazil and is on his way to the United States after losing Sunday’s presidential election to the leftwing incumbent, Luiz Inácio Lula da Silva, who called the act “shameful”.

A report by the news website Metrópoles, citing people close to the politician’s family, said he was en route to the US. “The plane is in flight,” Metrópoles reported, without making clear where it had departed from.

Три часа ночи, API отвечает 500, и рука сама набирает systemctl restart. Иногда это помогает, но есть инциденты, где рестарт добивает то, что ещё работало, и стирает улики. Пять таких: битый конфиг, OOM killer, retry storm, CrashLoopBackOff и диск, забитый логом, — с командами, которые находят настоящую причину, и шпаргалкой на одну таблицу.

Retailers also report jump in purchases of wind-up radios and torches to deal with extreme weather and cyber-attacks

Sales of tinned foods, bottled water, wind-up radios and torches have surged after the UK government advised households to prepare for emergencies.

Retailers have reported a jump in sales of items linked to preparation for emergencies such as extreme weather or cyber-attacks. The Be Ready campaign was launched last week with the aim of persuading households to lay in supplies to last 72 hours.

Пароль от тестовой базы лежит в .env, токен внешнего API — в переменных CI, доступ к production передают через корпоративный менеджер паролей. Новый разработчик собирает конфигурацию по нескольким источникам, а после смены пароля кто-нибудь обязательно запускает приложение со старым значением.

Пока сервисов и сотрудников немного, с этим можно жить. С ростом команды появляются вопросы: кто имеет доступ к секретам, где находятся их копии, как обновить credentials у всех потребителей и что произойдёт после отзыва доступа?

В этой статье разберём, как устроено централизованное хранение секретов, сравним восемь инструментов и посмотрим, что стоит проверить до внедрения. Основной практический сценарий — Java/Spring Boot, Gradle.

Всем привет!

В данной статье я хочу попробовать исправить проблемы произведения Джона Нэша.

Я познакомлю с этими проблемами и попытаюсь их исправить (лью воду ради 100 символов).

Frontline near Russian-occupied city in southern Ukraine quiet for first time in years ahead of planned evacuation

A local ceasefire in a southern Ukrainian city under Russian occupation appeared to be holding on Tuesday, with both sides ceasing drone attacks ahead of an apparent evacuation of about 2,000 trapped and desperate civilians.

The temporary truce began at 3am in Russian-controlled Oleshky. The city sits on the Dnipro River and is about 3 miles (5km) from Kherson, a larger city on the opposite bank. Ukrainian troops recaptured Kherson in autumn 2022.

Агент на пентесте сам решил перезапустить базу данных, потому что она ему мешала. Он рассчитывал, что сервис поднимется, результат не проверил и пошёл дальше. База не поднялась. Это был мой стенд и моя база, поэтому история закончилась смешно. Александр Кельчин, CTO и CISO Medici Lab, ронял агентами демостенды заказчиков, причём по договорённости.

В предыдущей серии: Краткое содержание части 1 и 2.

• Часть 1. «Прайс из Китая»

История о том, как в ИТ-отделе крупной компании "ИнвестБолт", которая знает цену специфики ВЭД с Китаем, наступило начало прекрасного дня: сеньор Михалыч флегматично чистил воблу, тимлид Антон Павлович пил кофе, а амбициозный 22-летний джуниор Данила (самопровозглашенный «Промпт-Архитектор») радовался жизни. Это был его первый официальный рабочий день после долгих месяцев штурма Хедхантера, и Данила чувствовал себя баловнем судьбы. Он искренне верил, что ИИ уже заменил сеньоров, ведь нейросеть по его первому запросу сгенерировала синтаксически идеальный код для управляемых форм, решил загрузить «быстренько и красивенько» китайский прайс на 300 000 строк из Гуанчжоу. Доверившись ИИ, он скормил файл платформе через ТабличныйДокумент.Прочитать(). Итог: Данила уронил рабочий сервер в разгар закрытия квартала у бухгалтерии.

• Часть 2. «Визит Анастасии Марковны»

Решив, что один поток — это прошлый век, Данила выбил из нейросети новый «универсальный рецепт» и бахнул многопоточность через ФоновыеЗадания.Выполнить(). Одно нажатие кнопки — и сервер 1С породил неуправляемую лавину фоновых процессов. Михалычу пришлось вручную вычислять сеанс «Пациента Зеро» в консоли администрирования и спасти базу, чтобы сменить гнев на милость главбуха Анастасии Марковны.

Часть 3. Скидка трейдеров Гуанчжоу.

Действующие лица:

• Сеньор (Михалыч) — излучает абсолютное спокойствие.

• Джуниор (Данила) — смотрит на Михалыча как на средневекового инквизитора.

Frontline near Russian-occupied city in southern Ukraine quiet for first time in years ahead of planned evacuation

A local ceasefire in a southern Ukrainian city under Russian occupation appeared to be holding on Tuesday, with both sides ceasing drone attacks ahead of an apparent evacuation of about 2,000 trapped and desperate civilians.

The temporary truce began at 3am in Russian-controlled Oleshky. The city sits on the Dnipro River and is about 3 miles (5km) from Kherson, a larger city on the opposite bank. Ukrainian troops recaptured Kherson in autumn 2022.

As the weight-loss drugs become more common, some runners find the side-effects challenging. Here’s what experts say

• Women: was your autoimmune condition misdiagnosed?

Keri M, a marathoner in her 50s, knew the race would be terrible.

This feeling couldn’t be chalked up to inexperience. Keri, who asked us to omit her full name due to the sensitive subject matter, has completed dozens of half marathons and four full marathons.

Retailers also report jump in purchases of wind-up radios and torches to deal with extreme weather and cyber-attacks

Sales of tinned foods, bottled water, wind-up radios and torches have surged after the UK government advised households to prepare for emergencies.

Retailers have reported a jump in sales of items linked to preparation for emergencies such as extreme weather or cyber-attacks. The Be Ready campaign was launched last week with the aim of persuading households to lay in supplies to last 72 hours.

Как WAF отличает ваш скрипт на Python от реального Chrome, если заголовки полностью идентичны? Ответ зашит в сетевом стеке. Поддерживаемые шифры и порядок расширений TLS формируют уникальный отпечаток, который невозможно скрыть обычной подменой прокси.

Пошагово разбираем анатомию TLS-handshake, алгоритмы деанонимизации JA3/JA4 и учимся собирать правильный цифровой почерк с помощью uTLS.

• This latest deep dive into Meta’s Privacy Aware Infrastructure (PAI) takes a look at PrivacyLib. 
• A privacy requirement must hold as data moves through Meta’s diverse data and processing systems. Historically, supporting a new requirement meant implementing the same enforcement logic separately in each system. PrivacyLib replaces this with a common library that runs inside the clients of Meta’s data and processing systems.
• A system integrates with PrivacyLib once, and new privacy capabilities plug in as modules that reuse that integration. PrivacyLib performs billions of checks every second, and changes are simulated and rolled out per module. 
• For internal AI agents, whose data access paths may not be known in advance, tool calls on supported paths carry agent context to PrivacyLib. The propagated context links each access to its session, so modules can observe data use and block operations that are not allowed.

At Meta, many privacy requirements ultimately come down to the same question: Can we prove that a piece of data goes only where it is allowed? At Meta’s scale, rather than relying solely on manual privacy audits, which can go out of sync as systems change, we have developed Privacy Aware Infrastructure (PAI) to answer this question within the infrastructure itself. PAI offers efficient and reliable first-class privacy constructs embedded in Meta’s infrastructure so that products can keep evolving quickly.

In previous posts, we have covered how data understanding, data lineage, and Policy Zones (our information flow control technology) play a role in PAI. Now, we are diving deep into PrivacyLib, a common library that runs inside the clients of hundreds of our data and processing systems at the point of data access.

PrivacyLib plays an important role in the final stage of the broader PAI workflow: continuously enforcing and monitoring data flows.

Before PrivacyLib, we integrated privacy enforcement separately into the clients of each data and processing system for each requirement. With this approach, implementing a new requirement across systems could take months. Each new requirement, whether purpose limitation or data flow discovery, needed the same set of capabilities: covering a wide range of systems; deploying in weeks rather than months; running on every data access without becoming a latency problem; and rolling out enforcement changes without taking the fleet down. Over time, this approach became harder to scale as requirements and systems evolved.

PrivacyLib separates system integration from requirement implementation. We integrate each system once. When a requirement can be met at the point of data access, we implement it as a PrivacyLib module shared across the systems already integrated, so a new requirement no longer needs a separate implementation in each system. 

There are two kinds of modules: 

• Enforcing modules can block a data access. For example, Policy Zones enforces purpose limitation.
• Observing modules only record a data access. For example, Privacy Probes collects the runtime signals used to discover data flows. 

As internal AI agents became a new way of accessing data, we also added the Agent Observability module to observe agent-related data access events and help safeguard the data that agents can reach. Systems already integrated with PrivacyLib picked it up without new integration work, which is what integrating once buys: each new privacy capability arrives as a module, not as a project.

Engineering Challenges and Approaches of PrivacyLib at Meta’s Scale

PrivacyLib operates across a broad range of data access paths at Meta:

• More than a hundred libraries used to access data services, from key/value stores to AI features.
• Thousands of production services with versions of the deployed library.
• Millions of assets being accessed daily.
• Billions of checks every second.

Operating at this scale creates three engineering challenges:

Walkthrough: Protecting Messaging Metadata

To illustrate how everything comes together at Meta’s scale, let’s walk through a privacy requirement that needs to be upheld when processing messaging metadata.

Users exchange messages through apps like Messenger, which supports end-to-end encryption. As Messenger routes and delivers those messages, subject to applicable law, its backend systems process non-content messaging data (i.e., messaging metadata), such as information about when messages are sent or delivered, to improve product performance, detect abuse, and protect users from harmful conduct. 

A variety of these backend services use Logger, a client library that runs in the service process, to write this metadata to data warehouse tables. Before writing a record, the PrivacyLib integration inside Logger invokes Policy Zones, an enforcing module, to check whether the metadata may flow to the destination table. This check is broken down into two parts: what inputs need to be available to make a decision, and how the check is actually evaluated at runtime. After examining these two parts, we look at how PrivacyLib scales across systems and how changes roll out without disrupting the services in the path.

Annotating Messaging Metadata

Every Logger destination table has a LoggerConfig that describes the records written to it. MetadataTraceLoggerConfig defines one such configuration for message-delivery traces and marks it as containing messaging metadata:

final class MetadataTraceLoggerConfig extends LoggerConfigBase {
  use MessagingTrafficMetadataPolicyTrait;
  public function configure(
    LoggerFieldDefiner $fd,
  ): LoggerFieldDefiner {
    $this->annotateWithTableLevelPolicy();
    // Field and destination definitions
  }
}

A logging destination can have many writers, so the annotation describing its output data belongs to the destination rather than to each service that writes to it. If every service declared the annotation separately, the declarations could disagree, or a new writer could omit it entirely. Declaring it once in LoggerConfig gives every writer the same description of the data.

For this destination, MessagingTrafficMetadataPolicyTrait supplies the MESSAGING_TRAFFIC_METADATA table-level annotation, and annotateWithTableLevelPolicy() attaches it to the destination.

LoggerConfig is Logger’s own schema, and each system describes its data in its own format. To give PrivacyLib a single form to consume, Logger’s code-generation pipeline translates the configuration into a PrivacyLib-compatible artifact. The generated MetadataTraceLoggerConfigPrivacyLibArtifact is derived from MetadataTraceLoggerConfig and carries the destination identity and the messaging annotation:

/**
 * @codegen-source MetadataTraceLoggerConfig
 */
class MetadataTraceLoggerConfigPrivacyLibArtifact
  extends LoggerInputPrivacyLibArtifact {
  
  final public static function getAssetIDImpl(
  ): LoggerInputAssetID {
    return LoggerInputAssetID::get(
      'MetadataTraceLoggerConfig',
    );
  }

  protected static function getPurposePolicyVars(
  ): TPurposePolicyVars {
    return PurposePolicy::makeVars(
      TPurposePolicyName::MESSAGING_TRAFFIC_METADATA,
    );
  }

  // Other generated fields omitted.
}

The generated class above is used by Logger’s client in Hack, Meta’s typed PHP language. For its C++ and Python clients, Logger publishes destination identities and annotations to a central catalog. PrivacyLib uses that information to generate language-specific artifacts. In the C++ example in the next section, PrivacyLib uses the LoggerConfig name to load the C++ artifact for the destination.  

Running the Check

The artifact from the previous section describes one Logger destination. PrivacyLib also needs to know what a Logger write means and which modules should run. Logger’s Hack integration defines that once for all destinations:

$config->libraryConfig()->enablePrivacyLib(
  PrivacyLibOperation::write()
    ->input(
      PrivacyLibInput::instance(
        nameof ILoggerInputPrivacyLibPayloadProvider,
      ),
    )
    ->enforcements(
      PrivacyLibWriteEnforcement::zones(
        ZoneDataType::LOGGER,
      )
        ->withPropagation()
        ->enabled(),
      PrivacyLibWriteEnforcement::telemetryLogging()->enabled(),
      // Other modules
    ),
);

PrivacyLibOperation::write() declares PrivacyLib’s write operation for Logger, and enforcements() lists the modules that run on it. The Policy Zones module can affect the result, while the Telemetry Logging module records the evaluation without affecting it. Adding a module here requires no changes to individual destinations or Logger call sites. ZoneDataType::LOGGER tells Policy Zones that it is checking a Logger destination.

In C++ services, Logger constructs the PrivacyLib request as follows: 

const auto assetList =
      std::vector<std::string>{configName};

PrivacyLibBuilder builder(
      "LOGGER_WRITE_CLIENT",
      assetList,
      LoggerWriteAPIEnumHelper::apiToHashedString(
          PolicyEnforcedLoggerWriteAPI::log),
      Caller::LOGGER,
      getLoggerWriteImplementation());

auto result =
      PrivacyLibRequest(std::move(builder)).dispatch();

PrivacyLib uses configName to load the destination’s artifact. The hashed PolicyEnforcedLoggerWriteAPI::log value maps Logger’s API to PrivacyLib’s write operation. The remaining builder arguments identify Logger as the caller and provide the implementation that performs the write. dispatch() invokes the configured modules and records their outcomes. For the Policy Zones module, PrivacyLib provides the destination annotations from the generated artifact and the current processing context. For this example, Policy Zones evaluates two conditions:

1. The current context represents an allowed use of messaging metadata.
2. The destination artifact carries the MESSAGING_TRAFFIC_METADATA annotation.

When enforcement is enabled, the Policy Zones module denies the write if either condition fails. PrivacyLib combines the results from enforcing modules into one response. A denial stops the write before Logger sends the record downstream. Observing modules emit telemetry without affecting the response.

Scaling Privacy Checks Across Systems

PrivacyLib enables privacy checks to scale across heterogeneous systems through a common execution model, lightweight evaluation and telemetry, and coverage for requests that bypass integrated clients. 

A Common Execution Model Across Systems

PrivacyLib’s integrations span systems with very different APIs: key-value stores, graph databases, ML pipelines, filesystems, and logging systems like Logger. Each integration maps its access points to one of five common operations, and PrivacyLib invokes its modules at each:

1. Read: runs when fetching data.
2. Write: runs when storing data.
3. RPC: runs when calling another service.
4. Request entry: runs once when a service begins handling a request.
5. Inline execution: wraps a specific computation inside a larger request, such as evaluating a feature. Data accesses made during that computation are evaluated using its inline privacy context.

Modules are written against these five operations rather than against each system’s native API. Reads, writes, and RPCs also have post-operation variants, so observing modules can run after the access decision has been made. Once a system provides the mapping, every compatible module can reuse it, which is why enabling an additional module on an already-integrated system takes only days.

PrivacyLib runs inside the clients of data and processing systems because the clients already have the destination identity and request context that modules need. Keeping the evaluation in the same process avoids carrying those inputs across process boundaries on every access. This design also has two advantages:

1. Richer context: PrivacyLib can use the caller’s identity, endpoint, and purpose while that information is still available. This information is frequently lost if the check is evaluated on the datastore.
2. Failure isolation: A faulty change is contained to the service running that version of the code, keeping the shared datastore outside the failure boundary.

Keeping Checks Computationally Inexpensive

In-process evaluation must also be computationally efficient because it runs on every data access. Per-request caches eliminate repeated checks within a request and per-host caches retain frequently used configuration and results. This avoids the remote configuration fetch required by an earlier design (that fetch alone was thousands of times slower than the in-process path). The result is that PrivacyLib performs billions of checks per second across the fleet with low per-check latency, while consuming only a small fraction of Meta’s total compute capacity.

At PrivacyLib’s scale, telemetry must also remain lightweight. PrivacyLib records each module’s status, samples latency, and logs errors, giving us fleet-wide visibility into how enforcement is behaving in production. Recording every invocation in full detail would overwhelm the systems receiving those events, so the goal is to deduplicate repeated events while keeping rare ones visible. 

Two mechanisms work together to achieve this: Bloom filters on each host downsample high-volume patterns at a fixed rate, and fine-grained sampling rates adjust as traffic changes.

Covering Direct RPC Paths

Not every caller accesses data through a PrivacyLib-integrated client library; some issue raw RPCs. The RPC layer can still check those requests, but it sees far less context than the client does. PrivacyLib bridges that gap with a cryptographically-signed token: When a client-side check succeeds, PrivacyLib attaches the token to the request, and ServiceRouter validates it at a lower boundary for supported RPC traffic, confirming that the request already passed the richer client-side check.

When a request arrives at the RPC layer without a token, ServiceRouter falls back to a coarser check based only on the context visible in the network payload. Because that context is limited, the lower layer applies the strictest interpretation, choosing false positives over gaps. Between them, the two layers cover access through Meta-managed clients and supported RPC paths. Paths outside those boundaries are not covered by this mechanism and need their own PrivacyLib integration.

Together, the result is that evaluation stays local and computationally inexpensive wherever possible, with a coarser backstop where local evaluation is unavailable, and modules have one place to run across systems that otherwise share nothing. What remains is the harder operational question: how to change enforcement behavior without breaking live traffic or making incorrect access decisions.

Rolling Out Enforcement Changes Safely

Privacy requirements change over time. Updates to a destination’s annotation or an enforcing module can change whether a write is allowed. PrivacyLib has a safe rollout path for both types of changes.

Changing an Annotation

Adding or removing an annotation changes two lines in a LoggerConfig: the declaration that imports MessagingTrafficMetadataPolicyTrait and the call to annotateWithTableLevelPolicy(). Because the destination may have many writers, that two-line edit can begin blocking writes from many services at once.

Review is therefore built around showing the author and reviewers what the edit will actually do. During code review, Logger’s code-generation pipeline updates the destination’s PrivacyLib artifact. Simulations then replay observed data flows against both the new artifact and the existing one, and any flow whose result changes is reported. The source edit, the generated artifact, and the simulation results are reviewed together, so the decision rests on evidence of the change’s effect rather than only on reading the code change. If the simulation reports an unexpected change, reviewers hold the artifact before release.

Once approved, the artifact reaches services through their usual build and deployment pipeline. That gives two forms of visibility before the change is deployed, from the decision changes reported by the simulation and the generated code showing exactly what will be deployed, plus one form of control, since each service’s own deployment decides when the change reaches production. It also bounds the surface area: An issue found after deployment is limited to the services running that build.

The downside is that changes do not reach the entire fleet at once, making change propagation slower than a global configuration update. In practice, requirement owners use explicit tracking to update the services in scope by the required deadline, while a service that needs the update sooner can use its emergency deployment process.

Rolling Out a Module

An annotation change applies to one Logger destination. A module added to Logger’s write path runs for every Logger destination. We therefore deploy the module before enabling it across all traffic.

As an example, here is how Policy Zones was introduced on this path. We first set the Policy Zones module to rollingOut() in Logger’s PrivacyLib write-operation configuration:

PrivacyLibWriteEnforcement::zones(ZoneDataType::LOGGER)
    ->rollingOut()

The rollout key, logger.input.write.zones, identified this combination of Logger input, write operation and the Policy Zones module. rollingOut() placed the module execution behind a runtime control. We then moved that control from 0 to 100% in stages while monitoring denials, errors, and latency. If valid writes began to fail, we could lower the percentage without rebuilding or redeploying the service. The Telemetry Logging module continues to run because it is configured independently. 

Once the Policy Zones module was stable across Logger traffic, we changed the configuration from rollingOut() to enabled(). At this point, the Logger integration ran the module without consulting the rollout percentage.

Safeguards apply at different stages across the two change paths described above. If a simulation shows unexpected flow changes, we hold the annotation artifact before release. If a module misbehaves after the rollout begins, we lower its rollout percentage using the runtime control.

These safety mechanisms changed what it takes to meet a privacy requirement at Meta. PrivacyLib now runs inside the clients of hundreds of data and processing systems and evaluates billions of checks every second, while consuming a small fraction of Meta’s compute. Requirements built on top of it, such as purpose limitation through Policy Zones and data flow discovery through Privacy Probes, reuse those integrations instead of rebuilding them, so enabling a module on systems that are already covered takes days rather than the months bespoke integrations used to take. When a change does go wrong, the failure stays inside the service running the deployed change. We can now use that foundation for a newer class of workload: AI agents.

PrivacyLib Controls for AI Agents

AI agents are harder to reason about than traditional services because their behavior is dynamic and the data they access is determined at runtime. Therefore, we have to design for agent safety up front by enforcing controls, such as Policy Zones, not only on what we expected the agents to access when we built them but also on what they attempt to access at runtime. Where enabled, these controls can block a disallowed access before any data is returned.

Agents invoke tools to carry out tasks. A single tool call may cross several services in a nested manner before reaching data. To tackle this new challenge, we built AgentLib, a common runtime based on PrivacyLib’s design principles, for observing and governing tool calls made by internal agents. On supported paths, AgentLib associates each tool call with its agent session, and downstream clients and services propagate that context until the call reaches a system integrated with PrivacyLib. At that data access boundary, PrivacyLib combines the context, the requested operation, and the destination’s annotations, then passes them to individual modules to make a final decision.

Within PrivacyLib, the Agent Observability module records the agent session and tool-call identifiers alongside the destination, client API, integration point, and any errors. Engineers can query these events by session to investigate the services and destinations involved in a tool call. When we introduced the Agent Observability module, PrivacyLib’s existing broad coverage enabled us to instrument systems already integrated with the library instead of manually integrating the module into hundreds of systems. Even with AI-assisted development, this would have been a daunting task. 

To enforce certain policies, we used the existing Policy Zones module without modification because it relies on the same inputs for enforcement. On paths where this control is enabled, it considers the destination annotations and agent context before allowing an operation. When Policy Zones blocks an operation, PrivacyLib propagates that result back through the call chain to the agent environment. Policy Zones applies this check even when the agent chooses a tool that its developer did not anticipate. The access decision does not depend on the agent behaving as intended.

Lessons Learned From Building and Operating PrivacyLib

Building and operating PrivacyLib across Meta’s systems taught us a few important lessons.

Design for evolving systems and requirements: Before PrivacyLib, we added privacy controls to the individual call sites needed to satisfy each new requirement. Over time, Meta built new data and processing systems, services gained new ways to process data, and privacy requirements expanded. Each change created more integration work, and new access paths sometimes appeared faster than we could cover them. The lesson was to integrate at a stable data access boundary, define the small set of operations that systems share, and keep annotations with the data. Modules can reuse the same integrations and reduce engineering effort over time.

Reliability earns adoption: Early on, an invalid config crashed processes across the fleet, breaking our own safe rollout principles. Other incidents came from annotation changes that compiled successfully but changed access decisions and caused product failures. These incidents showed that service owners will trust PrivacyLib in a critical data access path only when they can see how changes affect their traffic before release and recover from a problematic change without a fleet-wide rollback. 

Coverage includes deployment: When new requirements need changes to modules or supported policies and annotations, older services need to deploy versions with the updated PrivacyLib capabilities. We have ensured that explicit inventory, tracking, and rollout mechanisms are in place to coordinate these deployments, so that requirement owners can meet deadlines safely by updating only the services in scope.

Looking Forward

These lessons shape where we are taking PrivacyLib next, as AI pushes data access into environments and call paths that are increasingly novel. We continue to enrich PrivacyLib’s capabilities in two areas:

1. AI training: Data used for training reaches our systems from a variety of environments. Much of it is produced or transformed in various places. We are extending PrivacyLib-style approaches to this domain so the same guarantees scale with it. For more on how Meta approaches AI training data, see AI at Meta: Transparency About Our Training Data.
2. Internal AI agents: Observing attempted data accesses and blocking disallowed ones is just the starting point rather than a finished picture for agents used internally at Meta for engineering and productivity. The harder problems come next: evaluating internal agent behavior while it is happening, and reasoning about communication between these agents, where a single data access may be several agents removed from the person who asked for it.

Acknowledgements

The authors would like to acknowledge the contributions of many current and former Meta employees who have played a crucial role in developing PrivacyLib over the years. In particular, we would like to extend special thanks to (in alphabetical order) Adwait Sathe, Andrew Vaslas, Darrien Glasser, Diana Marsala, Hanzhi Zhang, Kousik Nandy, Matthew Hillman, Matthieu Martin, Michael Dietz, Nathan Maue, Rachel Lee, Ramy Wassef, Sen Luo, Spencer Baumgardner, Vince Yang, and Zhong Hu. We would also like to express our gratitude to all reviewers of this post, including (in alphabetical order) Aleksandar Ilic, Alex Kagan, Alex Ponomarenko, Arash Nikkar, Avtar Brar, Chloe Lu, Chris Wiltz, Emil Vazquez, Emily Van Deuren, Rituraj Kirti, Sushaant Mujoo, and Wenlong Dong. We would like to especially thank Jonathan Bergeron for overseeing the effort and providing all of the guidance and valuable feedback, and Chloe Lu for pulling required support together to make this blog post happen.

The post PrivacyLib: Privacy Controls at the Data Access Boundary appeared first on Engineering at Meta.

Каждую неделю на GitHub появляется очередной «AI-powered pentesting agent», обещающий автоматизировать всё — от разведки до эксплуатации. Заявления впечатляют: «3600x ускорение по сравнению с человеком», «90% на бенчмарках», «охотник за zero-day уязвимостями».

Я собрал 12 инструментов — популярные AI-агенты для пентеста, проверенные классические DAST-сканеры и гибридную связку AI + DAST — и натравил их на одно и то же уязвимое приложение чтобы выяснить так ли они эффективны на самом деле. Одинаковые условия, режим «чёрного ящика», никаких подсказок.

Результат? Одна цифра скажет больше любого маркетинга. Но обо всём по порядку.

• The 2026 Python Typing Survey received 1,794 responses. 
• Type hint use changed little across three years, but checker selection changed sharply. 
• Among respondents who reported which checkers they use, half selected more than one, and missing library type information was the most common difficulty.

For the third consecutive year, we asked Python developers how they use and experience Python typing: the language features, specifications, and tools used to describe and check types in Python code. We run the survey to learn what is working and what library maintainers, tool builders, documentation authors, and standards contributors should tackle next.

Most respondents were experienced Python developers: 76.4% had used Python for at least five years. The clearest change was the shift in checker choice, while missing library type information remained the most common difficulty.

Key Takeaways From the 2026 Python Typing Survey

This year’s findings show several recurring opportunities:

Broader and more accurate type information would help users of data-science packages: Dynamic frameworks pose a different challenge because current type systems cannot express some runtime behavior. Possible directions include new typing features and checker support tailored to individual libraries and frameworks.

Tool builders could focus on editor feedback and an initial checker run that requires little configuration: Error messages could link to short explanations and examples. Typing documentation can assume Python experience. Projects using multiple checkers would benefit from clear explanations of intentional differences between them.

Better callable syntax remains a practical area for standards work, especially if improvements keep common typing tasks straightforward.

AI usage remains an open question: The findings on AI leave an open question about which interactions between AI tools and type checkers help developers. Further empirical study could inform future designs.

AI Tools Now Write Types and Respond to Checker Errors

The share of respondents who selected “Makes AI-generated code more accurate/reliable” rose from 18.5% in 2025 to 38.4% in 2026. AI tools wrote type hints for 42.5% of 1,517 respondents, while 32.6% wrote types to improve AI-generated code. Respondents also used AI to fix or explain type errors. Across all four activities listed for AI tool use in typing, 61.0% of respondents reported they used at least one of these options.

Some respondents said their AI coding tool runs the checker and then fixes the errors. Of the 1,517 developers who answered how they run a checker, 24.4%, said an AI coding tool invoked their checker. Among the 370 respondents, 61.6% also used AI to fix checker errors. The rate was 19.3% among everyone else.

Some respondents described AI-generated types that are too broad and agents that suppress checker errors:

“I fix AI coded type hints because AI often gets lazy and uses object for everything.”

“Lazy coding agents that spam #type: ignore comments everywhere.”

When asked how useful types are for better AI-assisted coding, 29.8% of 1,551 respondents chose “I’m not sure.” The uncertainty rate for AI-assisted coding was nearly four times the 7.7% rate for runtime guarantees, the next-highest of the six benefits. We still need empirical evidence about which interactions actually help.

The Pyrefly team is already studying how AI coding tools and type checkers work together. At the 2026 Python Typing Summit, the team presented Type Checking in Agentic Workflows.

Library Gaps Lead Overall; Occasional Users Struggle With Complexity

Missing type information in third-party libraries was the leading difficulty, selected by 65.1% of 1,486 respondents. Another 44.6% said the type system could not describe everything their code does.

Developers can still have a poor experience after a library ships dedicated stubs. Among 156 people who wrote their own answer, 22 described dynamic constructs, decorators, metaprogramming, or framework behavior. Ten described arrays, dataframes, or scientific typing, and at least eight described annotations that were inaccurate, incomplete, or too broad. Respondents repeatedly named Django, SQLAlchemy, Pydantic, NumPy, pandas, and Polars.

“Django does so much black magic it’s a wonder a type checker works at all.” — survey respondent

Library maintainers need annotations that capture how frameworks and data-science libraries behave. The Pyrefly team has been working with Quansight to improve third-party library typing, including contributions to pandas-stubs and NumPy.

Frequency of use changed which problems stood out. Among developers who used type hints rarely or sometimes, 41.6% found the type system too complex or verbose. The rate was 14.5% among developers who used type hints often or always. Missing library typing affected 36.2% of the lower-frequency group and 70.0% of the higher-frequency group.

“I use the straightforward parts and avoid the parts that are difficult to understand.” — survey respondent. 

Years of typing experience showed a different pattern. Complexity was reported by 18.2% of respondents with zero to two years of typing experience, 16.0% with three to six years, and 21.0% with seven or more. Newer typing users were often regular users and experienced Python developers: Of the 396 respondents with zero to two years of typing experience, 306 (77.3%) used type hints often or always and 345 (87.1%) had used Python for at least three years.

Guidance for developers who are new to typing should assume Python experience and show how to add types to an existing repository. Occasional users need a useful first check with little configuration and easy-to-understand errors. As we change the type system, we should aim to support more patterns without making common tasks harder.

Better Callable syntax is one practical place to start. It was the most selected missing feature, chosen by 45.7% of the 1,486 respondents who answered the question. The selection rate was similar for respondents who reported complexity and the rest of the sample.

Newer Checkers Gained Ground Quickly

Frequent type hint use remained between 85.5% and 88.0% across the three surveys: 88.0% in 2024, 85.9% in 2025, and 85.5% in 2026. A different group answered each year, but the overall rate remained consistent.

Checker choice was far less stable. When the 2024 Python Typing survey asked what feature was missing from the Python type system, one response now reads like a preview of the changes captured in this year’s results:

“A faster Mypy. Its lack of speed led to ecosystem fracturing and other type checkers don’t support Mypy plugins and behave differently in general.” – survey respondent

By 2026, developers had several newer open-source checkers to choose from. Speed or performance topped the reasons for choosing a checker, at 56.5%. Using the same list of checkers in both years, 49.9% selected two or more in 2026, up from 46.0% in 2025.

Developers Mix Checkers Across Their Workflows

Of the 700 respondents who selected Mypy, 297 also selected its editor plugin. Another 314 selected a different named checker integration without selecting the Mypy plugin.

Most Pyrefly respondents also selected another checker: 220 of 264, or 83.3%. In the free-text responses, developers described why their teams divide work between checkers:

“Because my team members use different IDEs, we use multiple type checkers for development, but rely on Mypy for linting (local and CI).” — survey respondent

“Locally we primarily use Pyright because it’s the only option we’ve tried that fully understands all the more niche typing patterns within our codebase. In CI/CD, we do a Pyrefly run and only run Pyright on files where Pyrefly fails, to improve performance of the check.” — survey respondent 

Among the 1,486 developers who answered the question about difficulties, 33.3% reported inconsistencies between checkers. Among the 738 respondents who selected multiple static checkers and answered the difficulty question, 315 (42.7%) reported inconsistencies between checkers.

IDE Support Remains Central as Typing Help Moves Away From Stack Overflow

Readability or documentation was the most selected reason to use type hints, chosen by 93.6% of 1,571 respondents. Editor support also ranked highly: 84.8% of the 1,494 people who gave it a numeric rating chose 4 or 5. About 39% of the 103 developers who supplied their own reason mentioned completion, navigation, hover information, or editor error messages.

“Drastically improves IDE tooltip/autocomplete.” – survey respondent 

Real-time editor feedback was widespread: 82.9% of 1,517 respondents ran a type checker in an editor. VS Code was the most selected editor or IDE, at 59.3%.

Where developers look for help has changed as well. From 2024 to 2026, Stack Overflow use fell from 46.4% to 22.9%, while large language model (LLM) chat rose from 26.0% to 41.7%. Python typing documentation rose from 56.2% to 65.9%. Checker-specific documentation ended at 60.5%, up from 52.2% after a dip in 2025. General Python documentation fell from 66.7% to 62.2%.

As developers move from Stack Overflow to typing- and checker-specific documentation, the quality of those sources matters more. Error messages should link to short, relevant explanations and examples. Links to documentation would also give LLM chat tools better information to work with.

Survey Results and Raw Data

Download the full results and data from the Python Typing Survey 2026.

Acknowledgements

The survey ran from August 5 through September 2, 2026. It was developed with support from the Pyrefly team at Meta, the PyCharm team at JetBrains, the Python team at Microsoft, the ty team at Astral/OpenAI, and community contributors on discuss.python.org. We shared it through Reddit, X, Mastodon, newsletters, the Python typing forum, LinkedIn, Bluesky, Discord, Slack, and type-checker project websites and social accounts. We lightly edited quotations for spelling, grammar, and punctuation. We thank everyone who responded, shared the survey, reviewed the data, or contributed to the Python typing community.

The post Python Typing Survey 2026: AI Tools and the Shifting Checker Landscape appeared first on Engineering at Meta.