Technology Radar Vol 35
Languages & Frameworks
Adopt
-
104. Open Data Contract Standard (ODCS)
The Open Data Contract Standard (ODCS) defines data contracts declaratively in YAML, covering a data product's schema, quality expectations and service levels. It’s developed by the Linux Foundation's Bitol project, which graduated in July 2026. Although several competing standards and homegrown formats exist, ODCS has emerged as a leading standard, with the maintainers of Data Contract CLI deprecating DCS in favor of ODCS.
Several of our clients building data meshes and data products are moving to ODCS, often alongside the Open Data Product Standard (ODPS). Interest in data contracts is also growing, partly because their declarative format makes them easier for both humans and AI agents to interpret, review and validate. We’re placing ODCS in Adopt as a sensible default for teams building data products.
Trial
-
105. BoTorch
BoTorch is an open-source, PyTorch-based framework for Bayesian optimization. While Bayesian optimization is often used for hyperparameter tuning, we’re seeing it increasingly applied to real-world scientific and engineering problems. When standard tools for this challenge fall short, BoTorch provides the modularity and low-level control needed to construct probabilistic models and custom acquisition functions.
Paired with Ax for experiment orchestration, BoTorch excels in domains such as product formulation and R&D optimization, where physical or experimental evaluations are costly and exhaustive search is impractical. In these complex search spaces, BoTorch helps teams efficiently navigate trade-offs and maximize a limited evaluation budget.
-
106. Deep Agents
Deep Agents is an open-source agent harness from LangChain, built for long-running tasks. Deep Agents provides an opinionated architecture for breaking down problems, delegating work to subagents and managing execution. It includes key harness features such as planning tools, agent skills, memory, human-in-the-loop checkpoints and filesystem access.
Available as Python and TypeScript libraries, Deep Agents integrates well with LangChain and LangGraph. It’s particularly useful when specific steps in a complex agentic graph require a capable, long-running agent. In our experience, it complements multi-agent research and legacy modernization use cases and integrates with the broader LangChain ecosystem, including observability tools like Langfuse.
-
107. Kagent
Kagent is an open-source programming framework and Kubernetes-native platform for building, running and managing AI agents. Instead of requiring bespoke infrastructure, the framework turns agents into standard Kubernetes custom resource definitions (CRDs) that teams can deploy, scale and secure using their existing GitOps pipelines. This allows teams proficient in Kubernetes to build custom agents without needing to learn a new operational model. Kagent provides a built-in runtime with OpenTelemetry, secure sandboxing, memory support and native Model Context Protocol (MCP) integrations to easily connect agents with external tools and model providers.
We've moved Kagent into Trial after successfully using it to support production environments. At a recent client, we transitioned a multi-agent support bot to Kagent from a previous tool that restricted connections to a single MCP server and required hosting on a personal account. Because the client's team was already familiar with Kubernetes, the migration was simple. The resulting deployment features an orchestrator and multiple specialist agents that use Kagent's built-in Agent-to-Agent (A2A) Protocol to communicate, helping developers debug incidents and solve general questions directly within team channels.
-
108. OpenFGA
OpenFGA is an open-source, fine-grained authorization system inspired by Google’s Zanzibar. It models relationships between users and resources to determine permissions, enabling applications to answer questions such as “Can this user access this resource?”
Unlike traditional role-based access control (RBAC), OpenFGA supports complex, resource-specific permissions and hierarchical relationships. It centralizes authorization logic, improving maintainability, consistency, testing and auditing across distributed services.
We’ve successfully used OpenFGA in production for sophisticated relationship-based access control (ReBAC), deploying it with a sidecar strategy to enable low-latency permission checks. It’s a compelling choice when standard RBAC becomes insufficient.
-
109. Presidio
Presidio is a data protection SDK for identifying and anonymizing sensitive data in structured and unstructured text. It detects personally identifiable information (PII) such as credit card numbers, names and locations using named entity recognition, regular expressions and rule-based logic. Presidio supports custom entity recognizers and de-identification pipelines, allowing organizations to tailor it to their privacy and compliance needs. Our teams have used Presidio in enterprise environments with strict data-sharing controls when integrating with LLMs. While it automates the detection of sensitive information, it isn’t foolproof and may miss or misidentify entities. Teams should exercise caution when relying on its results.
-
110. Promptfoo
We put Promptfoo in Assess in 2023 for testing prompts. We still use it for evals, including agent tool calls and CI gates, but now also for red teaming. We recommend trialing it for both. To red-team an app, you describe what it's for, and Promptfoo generates attacks for the risks you choose, applies attack strategies and grades the responses.
We used Promptfoo to red-team a production conversational assistant with domain-specific safety rules. It turned ad hoc manual probing into repeatable tests rerun after every fix. It also works with stateful guardrails: the guardrails are the runtime control, and Promptfoo tests that they hold. Promptfoo is now owned by OpenAI, although it remains MIT-licensed and is model agnostic. Some of Promptfoo's more advanced simulated attacks rely on its hosted service, so make sure you're comfortable with what data leaves your organization.
Assess
-
111. Apple Core AI
Apple Core AI is a recently launched framework for running AI and machine-learning models directly on devices using Apple Silicon. Providing native Swift support for mobile development, it acts as the modern successor to Apple's previous framework, Core ML. Apple Core AI allows developers to integrate AI features natively into their iOS applications, using on-device compute rather than relying on external services.
A particularly notable capability in this ecosystem is the Evaluations framework in Xcode, which extends Swift Testing to evaluate generative AI features built with Apple's Foundation Models. Evaluating nondeterministic LLM output has historically required custom back-end scripts or third-party AI evaluation tools. Now, teams can run synthetic datasets, measure quantitative metrics in code and apply model-as-a-judge scoring for qualitative criteria such as tone and relevance, all within native developer workflows.
-
112. CALM
The Common Architecture Language Model, or **CALM**, is an open-source specification from FINOS for defining software architectures in a standardized, machine-readable format. Built on an extensible JSON meta-schema, it treats architecture as code rather than relying on static diagrams and documentation that can drift from implementation.
In large enterprises, ensuring systems follow established design patterns can be challenging. CALM allows teams to define and manage architecture in a decentralized way while maintaining a unified view when needed. Its structured descriptions can also support validation against the intended architecture. While tools like Mermaid support diagrams as code, CALM provides a machine-readable foundation for architectural compliance and programmatic governance.
-
113. Hindsight
Hindsight is Vectorize's open-source memory system for AI agents. An LLM extracts facts, entities and timestamps from conversations and stores them in Postgres. Recall combines semantic, keyword, graph and time-based search and reranks the results. A reflect operation consolidates stored memories into observations and "mental models" that evolve as new evidence arrives. This consolidation sets it apart from Mem0, which extracts and stores the facts it judges most relevant. Hindsight maintains a separate memory bank for each user or agent and can be self-hosted or used through the managed Hindsight Cloud service. Agents connect to it through SDKs, framework integrations or an MCP server.
Hindsight is particularly useful for custom-built agents that need memory across sessions. One of our teams used it in a hackathon project to give agents per-user memory that improves over repeated sessions. Hindsight also has plugins for coding agents such as Claude Code, although those agents already have their own mechanism for retaining memory across sessions. The vendor reports leading scores on the LongMemEval benchmark, which tests recall over long chat histories. Teams building agents that need long-term memory for each user should compare Hindsight with Mem0 and measure whether its recall and consolidation capabilities improve agent behavior enough to justify the additional LLM calls and infrastructure.
-
114. Quint
Quint is a formal specification language based on the underlying calculus of TLA+, the temporal logic of actions. Like TLA+, it's designed to help you find subtle bugs in complex systems involving concurrency. Quint distinguishes itself from TLA+ through its readability and developer experience. It has a TypeScript-like syntax that makes review easier, especially when agents write the specification. It also has a type checker, REPL and simulator and can be installed with npm. The simulator exercises the model inexpensively with randomized runs and can also generate traces from the spec to test an implementation. Our teams have found the choice between Quint and TLA+ a close call, weighing Quint's tooling against TLA+'s maturity. We hope that its ongoing development signals growing momentum behind polyglot verification.
-
115. SolidJS
SolidJS is a declarative JavaScript library for creating user interfaces that continues to stand out for its high performance and fine-grained reactivity. Recent updates introduce significant built-in capabilities for asynchronous client-to-server communication. By handling these concerns natively, SolidJS eliminates the need for external libraries to manage API calls, caching and request deduplication. These features improve the developer experience by addressing common asynchronous challenges, such as race conditions and loading states, directly within the framework. SolidJS also provides detailed control over suspense boundaries, allowing developers to sequence how asynchronous components are revealed rather than leaving their order to network availability. Coupled with an expanding toolset that includes the SolidStart framework, SolidJS is a compelling alternative worth exploring for building high-performance web applications.
-
116. spartan/ui
spartan/ui applies the approach of shadcn to Angular. You install accessible, unstyled primitives built on the Angular CDK from npm and combine them with styled components that live in your own source code. This division is central to the design: accessibility, behavior and state are maintained by upstream libraries, while you control the styling.
It's a credible Angular Material alternative. One of our teams used it as the basis for a branded component library across several applications, avoiding the need to build a design system from scratch and reducing the effort required to build and maintain shared components. spartan/ui reached version 1.0 in June 2026, but it's still relatively young. We've encountered some rough edges when using the CLI to upgrade the styled components in our source code, so we’re keeping it in Assess.
-
117. TLA+
TLA+ is a formal specification language for identifying design flaws in distributed systems. When we last blipped it in 2015, the investment was too high for all but critical systems. Since then, coding agents have changed the calculus: the cost of using TLA+ has gone down, while its value has gone up. TLA+'s awkward developer experience is no longer a blocker, although teams looking for friendly syntax might prefer Quint. We've observed teams verify application traces against a TLA+ model without prior experience.
Meanwhile, developers now have greater need for quality assurance techniques to manage agent-generated code. Where TLA+ was once the preserve of organizations like AWS, which used it to find subtle bugs in DynamoDB, it's now part of a broader trend of polyglot verification, alongside techniques like mutation testing and property-based unit testing.
Caution
Unable to find something you expected to see?
Each edition of the Radar features blips reflecting what we came across during the previous six months. We might have covered what you are looking for on a previous Radar already. We sometimes cull things just because there are too many to talk about. A blip might also be missing because the Radar reflects our experience, it is not based on a comprehensive market analysis.
