Technology Radar Vol 35
Tools
Adopt
-
68. mise
Since our last assessment, mise has evolved from a high-performance alternative to asdf into a default frontend for the development environment. We’re keeping it in Adopt because it consolidates three fragmented concerns (tool and language versioning, environment variable management and task execution) into a single high-performance, Rust-based tool, configured through a declarative mise.toml file. mise is easy to set up and works well with CI/CD pipelines. It also adds a layer of supply chain security through integration with Cosign and GitHub artifact attestations, which is often missing from other version managers.
For teams looking to standardize their developer environment setup, mise has become our recommended default. In polyglot environments with multiple microservices, this is especially useful when codebases adopt new language versions at the same time. Best of all, mise also works with existing language-specific tooling, so teams do not need to migrate all at once.
-
69. OpenAI Codex
OpenAI Codex moves to Adopt, joining Claude Code and OpenCode as CLI-first coding agents our teams use day to day. Its desktop app is popular with non-coders. Codex has the features you'd expect for enterprise adoption: OS-level sandboxing, tiered approvals, central configuration and compliance management. The underlying agent loop is Apache-2.0 licensed and can be used for the technique we call coding harness for general-purpose agents. Although open source, Codex is corporate-run rather than community-governed. It employs the classic challenger's gambit of compatibility: it makes it easy to import configuration, skills and sessions from other agents and to use models besides OpenAI's GPTs. That makes Codex a solid choice for running open-weight models.
-
70. OpenCode
Since our last Radar, OpenCode remains one of the most prominent open-source coding agent harnesses. We’ve seen its adoption grow significantly alongside the rise of capable open-weight models. Teams appreciate its customizability and headless/server mode, which make it an attractive foundation for organizations building an enterprise harness. On the downside, its session-sharing and collaboration capabilities still lag behind competing harnesses. OpenCode has become a popular choice for teams pairing coding agents with self-hosted, open-weight models and local coding models, but we still recommend evaluating emerging alternatives such as Pi.
Trial
-
71. Act
Act runs GitHub Actions workflows locally, replacing the commit–push–wait loop with faster feedback. We mentioned it in our GitHub Actions blip back in 2021. Coding agents give Act new relevance because the growing volume of commits and pushes can cause build contention. Act lets coding agents run a workflow locally before pushing, bringing CI directly into their generative loop and supporting agent pipeline responsibility.
Our teams find that Act handles most GitHub Actions workflow development, although it isn't a perfect replica of the GitHub Actions environment. For example, its default images lack some runner tools, and it doesn’t support concurrency, permissions and environment secrets. Paired with static checking such as zizmor, Act helps coding agents keep the build working when they change the pipeline itself.
-
72. Agent Package Manager
Agent Package Manager is an open-source dependency manager for AI agent configuration. It works via a manifest that declares plugins, skills, instructions and MCP servers. We use it to publish versioned skills from a central repository instead of copy-pasting files around. It treats agent context as a supply chain, installing from Git repos or an agent plugin marketplace and scanning for hidden Unicode that could hijack behavior. Its lock files record content hashes and provenance, while its SBOMs export to CycloneDX and SPDX formats. Auditing detects drift, and a policy file constrains sources, scopes and primitives, making an enterprise harness reproducible and governed. It's still a pre-1.0, community-driven project, albeit one sponsored by a major player, so we place it in Trial rather than Adopt and expect competing solutions to follow.
-
73. ast-grep
ast-grep is a command-line tool for structural code search, linting and rewriting. Patterns are written as ordinary code with wildcards for any syntax node and match against the syntax tree rather than text, using tree-sitter parsers for more than 20 languages. Linting and rewriting rules are written in a declarative YAML format. One of our teams used these rules as part of the harness around a coding agent, checking the agent’s code against a set of custom rules and feeding the results back to the agent.
ast-grep is similar to the tools behind code intelligence as agentic tooling, but it doesn't build an index or require a language server. Because it skips indexing, it's a low-friction first step for a large codebase before committing to heavier tools. Unlike most tools in that group, it also has uses that don't involve agents: developers can run the same searches, lint rules and rewrites themselves. ast-grep covers much the same ground as Comby, which we featured in 2021. Most IDEs already offer AST-based search, but they don't replace the custom lint rules and rewrites that set ast-grep apart.
-
74. Beads
Beads is a Git-backed issue tracker that coding agents can share to coordinate their work. In place of ad hoc Markdown plans, it gives agents a persistent, structured task graph. Because Beads stores tasks and their dependencies alongside the code, agents retain their plans and newly discovered tasks across sessions and context compaction. Each agent can claim the next available task without colliding with others.
We're moving Beads to Trial because many of our developers now use it by default with coding agents. It complements team issue trackers such as Linear, which teams use to plan, prioritize and track work. Beads holds the finer-grained tasks agents create as they work, and it syncs both ways with Linear, Jira and GitHub Issues.
Since we last featured it, Beads has reached 1.0 and moved to the Gas Town Hall organization. It’s maintained by Gas City, the company behind Gas Town. Dolt is now its only storage backend, and additions such as an HTTP API, work leases and synchronization between stores make Beads heavier than the lightweight tracker it started as. Upgrades migrate the schema in place, and clients running different versions can't share a store, so teams should pin a single version for each shared store and review the instructions Beads writes into AGENTS.md.
-
75. Chaos Mesh
Chaos Mesh is an open-source Chaos Engineering toolkit for injecting controlled failures into cloud-native systems. Chaos Mesh defines fault simulations as declarative Kubernetes custom resources, allowing teams to use familiar tooling and manage chaos experiments through version control. We've found that its range of simulated failure scenarios, reproducibility and blast radius controls make it suitable for repeatable, automated testing at scale. This includes environments with GPU-dense AI infrastructure, where validating resilience can be particularly challenging but important.
-
76. Cube Core
As analytics data is increasingly consumed by both custom applications and AI agents, defining metrics directly in dashboards or individual SQL queries often leads to duplication and metric drift. Cube Core is an open-source semantic layer that addresses this challenge by allowing teams to define metrics, dimensions, joins and access rules as code. By creating a governed, reusable semantic model, teams can define business metrics once and expose them consistently across BI tools, embedded analytics and AI workflows through standard APIs.
We've used Cube Core successfully to implement a semantic layer in recent projects. The tool has an active codebase and contributor community. If you're struggling with inconsistent data definitions across multiple consumption layers, we recommend evaluating Cube Core to standardize analytics access.
-
77. Figma Code Connect
Generic design-to-code tools often turn frames into raw markup that ignores a team's existing components, resulting in code that needs to be rewritten. Figma Code Connect addresses this disconnect by mapping Figma components directly to production UI components in code. Instead of guessing component APIs, AI tools and developers can use these mappings to generate code with your actual component signatures and props. This structured approach grounds code generation in the existing design system.
This tool is particularly relevant as teams move from prompt-based code generation to more controlled, agentic workflows. By pairing Figma Code Connect with the Figma MCP server and coding agents, developers can provide agents with context from the actual codebase. This helps shift free-form code generation toward more deterministic, production-compliant component assembly, reducing code review iterations and the risk of architectural drift.
In our experience with mobile design systems, we've used this workflow to map components across iOS and Android, auto-publishing to Figma after main-branch releases and using continuous integration (CI) to detect drift. However, Figma-to-code generation is only as reliable as the underlying design system. Generated output still requires guardrails, such as lint checks to block hardcoded colors and snapshot baselines on every pull request. Maintaining mappings for every variant also requires ongoing effort, and the tool currently operates at the component level rather than validating complete product screens. Layout logic, state and navigation therefore still require human oversight.
-
78. FluxMarkdown
FluxMarkdown is a macOS QuickLook plugin that renders Markdown files directly in the Finder preview panel. While other options like QLMarkdown exist, FluxMarkdown offers comprehensive support for syntax highlighting, mathematical notations via KaTeX and complex diagrams using Mermaid, Graphviz and Vega.
We've found FluxMarkdown useful for inspecting documentation because it eliminates the need to open a dedicated editor just to view a rendered diagram or equation. As developers increasingly rely on command-line interfaces and autonomous agents in their workflows, viewing rendered Markdown files can still require opening an IDE. FluxMarkdown provides a lightweight alternative that lets developers preview these files without leaving Finder.
-
79. Git AI
Git AI is an open-source Git extension designed to track AI-generated code in repositories. It links AI-written lines to the agents, models and prompts that generated them. Using checkpoints and hooks, the tool tracks incremental code changes throughout development. Each checkpoint contains a diff between the current state and the previous one, marking lines as either human- or AI-authored. This approach provides more detailed attribution of AI contributions than simply counting lines of code at the time they’re added.
The extension uses an open standard based on git notes to track AI-generated code. As AI-generated code becomes more common in everyday development, maintaining accountability and understanding the original intent behind code becomes increasingly important. Both developers and AI agents can query archived sessions to retrieve the original context and design decisions. Given its potential value for accountability and maintainability in agentic workflows, we’ve moved Git AI to Trial.
-
80. Linear
Linear is an issue tracker that pairs the easy setup of Trello with the planning features teams usually turn to Jira for. Many startups have used it in place of Jira for years, and its recent appeal comes from how well it works with coding agents. Agents join a Linear workspace as members, so teams can assign them issues, mention them in comments and see the reasoning behind each change. Cursor, OpenAI Codex and Devin can all take on work this way, while Linear's remote MCP server lets tools such as Claude Code read and update issues. Linear holds the work a team plans and prioritizes. Beads sits a level below it, tracking the smaller tasks agents create as they go. We often use Linear with clients whose teams work heavily with coding agents. Teams that choose their own tooling should consider trialing it if they want agents to pick up work directly from the backlog.
-
81. mattpocock/skills
mattpocock/skills ("Skills For Real Engineers") is a collection of agent skills for agentic software engineering. The skills provide a suggested workflow but are explicitly designed to be small, easy to adapt, and composable. We’ve found them valuable for helping teams apply sound software engineering practices to agentic coding, as well as for AI-assisted analysis of requirements and assumptions, such as grilling. While we caution against adopting entire skill libraries without evaluating them (agent skill cognitive surrender), these lightweight skills are worth a look if you want more structure in your agentic software development workflows.
-
82. OpenSpec
OpenSpec is a lightweight spec-driven development framework that works with any coding agent. Since we featured it in Assess in April, several of our teams have reported success with it, enough to move it to Trial. We particularly appreciate how it works on brownfield codebases, retrofitting specs onto existing code. Teams report more predictable agent output and fewer unintended changes compared to bare prompting. OpenSpec's key differentiator over competitors like GitHub Spec Kit and Kiro is that it centers on a spec-anchored workflow. Changes are deltas against a persistent source-of-truth spec, so agents can rely on it as a current reference. The usual caution applies: spec files are Markdown that agents generate prolifically. OpenSpec's archiving of change deltas mitigates this, but maintaining the persistent spec still requires discipline.
-
83. OpenWiki
OpenWiki is a command-line interface that automatically writes and maintains a wiki for a codebase or personal knowledge repository. It synthesizes source materials into a linked Markdown wiki that other agents can use as context. OpenWiki is currently in our Trial ring as we evaluate its impact on active projects. Our experience has reinforced a familiar challenge: high-quality documentation is essential, but keeping it up to date is notoriously difficult. OpenWiki addresses this by using automated pipelines to update content as source material changes, with checkpointing to track when each piece of documentation was last generated.
OpenWiki also supports local models for private generation and the OKF format for structured documentation. For humans, it includes an interactive visualizer that presents the underlying wiki as an explorable node graph, helping them navigate and understand relationships across interconnected topics and codebase documents.
-
84. Pi
Pi is a minimal, open-source agent harness written in TypeScript. This blip covers the whole toolkit: the multi-provider LLM API (pi-ai), the agent runtime (pi-agent-core) and the terminal coding agent built on them (pi-coding-agent). Pi deliberately leaves out MCP, subagents, plan mode and permission prompts. You add what you need through extensions, agent skills and prompt templates. Pi can even write its own extensions. We're moving Pi to Trial because adoption has grown since the last Radar, mostly as a foundation for other tools. Security scanners and orchestration harnesses now run on Pi, often as an underlying dependency rather than a directly used tool, while its SDK and RPC modes let you embed it in other agent systems.
As a coding agent used directly, Pi isn't the strongest choice, and OpenCode is better suited as an enterprise coding harness. Oh My Pi, a popular fork, adds language server integration, subagents and MCP to create a full coding agent, but it has diverged enough to evaluate as a separate tool. Our concern last time was Pi’s dependence on one maintainer; in April 2026, its creator joined Earendil, which now owns Pi and has committed to keeping the core MIT-licensed while planning commercial add-ons.
-
85. Sourcebot
Just as developers need broad context across large, multi-repository enterprise codebases, software engineering agents need the same context to perform large-scale refactoring and navigate legacy ecosystems. Sourcebot is a self-hosted code search and understanding platform that acts as a context layer to serve both. It indexes thousands of repositories to provide fast, symbol-aware search and IDE-level navigation. With the Sourcebot MCP server, agents can search across an organization’s entire codebase. Our teams have also found the paid-tier feature Ask Sourcebot useful for team collaboration. This AI chat tool enables non-developer roles to query the codebase using natural language, reducing their reliance on developers to answer codebase questions.
-
86. Timefold Solver
Timefold Solver is an open-source constraint optimization engine for Java and Kotlin and the modern successor to OptaPlanner. It solves logistical planning problems, such as vehicle routing, employee rostering, task assignment and maintenance scheduling, where the space of possibilities is far too large to search exhaustively. Although branded under the broader AI umbrella, it involves no training data or learned model, relying instead on heuristic search over constraints you define. It models absolute business rules as hard constraints that a returned plan can’t violate and operational targets as soft constraints that it optimizes within. We’ve successfully used Timefold Solver in production in the supply chain domain to rapidly model complex business scenarios.
Assess
-
87. AgentsView
As AI-assisted coding becomes mainstream, AgentsView gives developers observability into coding sessions so they can analyze patterns and improve harness usage. AgentsView lets developers browse, search and perform context profiling on past AI coding sessions. It can automatically hook into popular coding harnesses, such as Claude Code, OpenAI Codex, OpenCode or Pi and retrieve historical sessions. It includes coding session analysis tools for metrics such as prompt-cache and cost efficiency, along with recommendations for improving harness usage. One thing we like about AgentsView is its local-first design, which makes adoption straightforward even for security-conscious organizations, while team synchronization and collaborative session reviews can be added later.
-
88. Apple container
Apple container is an open-source tool for running Linux containers natively on Apple silicon. Written in Swift, it uses Apple’s Containerization package to run a lightweight VM for each container rather than a monolithic Linux VM. This architecture provides hypervisor-level isolation and dynamic memory allocation, returning RAM to macOS when a container is torn down. It offers a native, lightweight alternative to shared-VM managers such as Colima and avoids the licensing requirements associated with Docker Desktop. When paired with community bridges such as Socktainer for Docker API compatibility, Apple container is particularly effective for local Testcontainers setups that require fast cold starts and strict resource boundaries. The project also includes Container Machine for running persistent, host-integrated Linux environments.
-
89. Deepsec
Deepsec is an agent-powered vulnerability scanner that first scans a codebase to understand its architecture, then launches targeted AI reviews against high-risk areas to produce vulnerability reports. What stands out is its hybrid architecture: it combines deterministic matching to identify high-risk files with dedicated subagents that inspect them. By narrowing the model's focus to where it matters most, Deepsec can reduce token consumption and cost compared to similar tools.
-
90. DeepSeek Harness (DSH)
DeepSeek Harness (DSH) is an open-source runtime from DeepSeek AI for building customized coding and general-purpose agents. Rather than offering a monolithic assistant, DSH uses an "everything is a plugin" architecture powered by the Cordis kernel. The model adapter, tool registry, session log and agent loop are all plugins, organized into profiles: named plugin lists that you extend and override in your own YAML.
Cordis is a meta-framework built around spatiotemporal composability: plugins contribute registrations as reversible effects, so reloading and teardown unwind them predictably rather than leaving dangling state. The combination of this plugin architecture and spatiotemporal composability could provide a foundation for domain-specific enterprise harnesses and future self-improving harnesses.
DSH also treats observability as a first-class concern. Every model-visible interaction, including prompts, context injections, tool calls and subagent collaborations, is captured in an append-only session log. This allows runs to be inspected, resumed, forked, searched and replayed, providing a record of what a recomposed system actually did.
-
91. Entire CLI
Entire CLI hooks into Git to capture coding agent sessions, including prompts, transcripts, tool calls and files touched, and stores them in the repository alongside the commits they produced but outside the branch history. It works with Claude Code, Codex, Cursor, OpenCode, Pi and others. Since we last featured Entire CLI, one of our internal teams that works heavily with coding agents has used it to share every member's sessions. The team found it useful for seeing how teammates prompt, what their agents do with those prompts and how prompting affects the quality of the output. It could also help experienced developers show others how they work with agents.
Openness comes with a cost, however. Entire CLI keeps a permanent record of how each person prompts, and anyone with access to the repository can read it. When we tried introducing it to other teams, some developers pushed back. A coding agent can feel like a personal assistant, and they weren't comfortable sharing everything they asked it with the team. For those teams, AgentsView offers a local alternative, letting developers review their own sessions without sharing them. We suggest trying Entire CLI in highly collaborative teams with a strong culture of trust. It stays in Assess because our experience comes from one internal team, and we don't yet know how other teams can adopt it comfortably.
-
92. FreeToken
FreeToken is an open-source inference engine designed to run large open-weight mixture-of-experts (MoE) models on consumer hardware. As these models become more capable, their full weights can exceed the memory limits of consumer GPUs. Unlike general-purpose local model runners, FreeToken specializes in oversized MoE models by adaptively combining GPU memory, CPU execution, host memory and PCIe bandwidth. It dynamically caches active experts on the GPU and swaps them based on which experts are activated. By coordinating this process, FreeToken enables developers to run much larger models on existing or older hardware. We’re starting to see MoE offloading techniques incorporated into broader tools such as llama.cpp, which is used by Ollama, but FreeToken offers a specialized approach worth assessing.
-
93. GLM
As the capability gap between open and closed AI models shrinks, the GLM model family by Z.ai stands out for its performance on software engineering workloads. Using a roughly 700-billion-parameter mixture-of-experts (MoE) architecture, models such as GLM-5.3 achieve strong benchmark results in coding, reasoning and agentic tasks, driven largely by specialized post-training rather than pretraining scale alone. This makes GLM-5.3 one of the best open-weight models currently available for coding and software engineering.
We like GLM because it provides teams with an open-weight alternative that competes with proprietary frontier models and complex reasoning tasks. However, in our experience, the model can sometimes "think" too much, overanalyzing straightforward prompts. We advise teams to configure the reasoning effort based on the complexity of the workload.
-
94. Habit Hooks
Habit Hooks is an open-source code-quality coaching tool for AI coding agents. It runs existing static-analysis and linting tools such as Ruff, ESLint, Knip, PMD, deptry and jscpd. Instead of returning raw linter errors, it translates tool-specific rule violations into actionable forward guidance and code smell context. A bare linter violation tells an AI agent that a check has failed but might encourage a superficial change that merely satisfies the rule. Habit Hooks maps the finding to the associated code smell and deterministically injects explicit guidance into the model's prompt. This context helps the agent address the actual design problem and self-correct immediately without relying on an LLM to generate the recommendation. The tool provides a practical implementation of feedback sensors for coding agents, integrating deterministic checks into the implementation loop so agents can respond to failures before human review.
-
95. Herdr
Herdr is an open-source terminal multiplexer and runtime designed to manage multiple coding agent sessions. It provides familiar multiplexer capabilities such as panes, keyboard navigation, detaching and reattaching, making it easier for developers to migrate from tools such as tmux. Herdr keeps agents running in persistent terminal sessions while exposing agent-aware states such as working, blocked, done and idle. Integrations via a CLI allow agents to create panes, exchange prompts and coordinate work.
As developers increasingly run parallel coding agents across multiple workspaces, keeping track of which sessions require attention and how to resume interrupted work has become a new workflow challenge. Tools such as T3 Code, Orca and Paseo provide alternative experiences for developers who prefer a GUI. Teams managing parallel agents should assess Herdr if they want persistent sessions and visible agent status in their terminal workflow.
-
96. Hunk
Hunk is an open-source terminal diff viewer for reviewing changes made by coding agents. It displays a GitHub pull request or a Git, Jujutsu or Sapling changeset as a multi-file review with a file sidebar and split or unified layouts. A watch mode refreshes the view as an agent edits the working tree. An agent can load Hunk's agent skill to drive a live review session, jumping to a file or Hunk and adding notes alongside the lines it changed. Reviewers can then read the agent's reasoning next to the relevant code. Those notes distinguish Hunk from syntax-aware diff tools such as Difftastic.
We aren't sure line-by-line human review of agent output will remain the norm, but many teams still need it today: skimping on it can lead to complacency with AI-generated code. The project started in March 2026 and hasn't yet reached version 1.0. Teams that review agent changes in the terminal should try Hunk and assess whether the agent's notes make reviews faster or simply give reviewers more to read.
-
97. nono.sh
nono.sh is an open-source security shell and lightweight sandbox designed to run AI agents without the overhead of traditional virtual machines or Docker containers. It addresses a common gap: although sandboxing is widely recommended, setup overhead can discourage teams from implementing it. nono.sh isolates agent processes directly at the OS level using native kernel features such as Landlock on Linux and Seatbelt on macOS. It operates in-process as native host processes without background daemons, blocking access to sensitive host assets, such as SSH keys, by default.
We think nono.sh is worth assessing because it lowers the barrier to process isolation. Its minimal design makes it straightforward to configure, test and integrate into existing workflows across macOS, Linux and Windows through WSL2. Security profiles can be tweaked, forked and shared across teams or the broader community through the nono registry, providing a low-overhead layer of defense for developers adopting autonomous tools such as Claude Code or OpenAI Codex.
-
98. OpenResearch CLI (orx)
OpenResearch CLI (orx) is an open-source harness that turns coding agents such as Claude Code into research agents that run experiments in parallel. Each experiment is isolated in its own Git worktree, so attempts don't interfere with one another. All experiments use the same run command, which keeps results comparable, and every run is pinned to an immutable snapshot of the code for reproducibility.
Because orx runs on compute you choose (local, Slurm, Kubernetes or Modal) teams can implement a method from a paper, reproduce its experiments and then test whether its results hold in their enterprise context. This can help identify the gap between academic results and enterprise practice. We think orx is worth assessing as a promising domain-specific harness for narrowing that gap.
-
99. Safe Chain
Safe Chain is a free tool from Aikido that wraps the package managers for Node.js and Python, such as npm, pnpm, Bun, pip and uv. It sends package downloads through a local proxy that blocks versions published in the last 48 hours and any package Aikido's open threat feed lists as malicious. Worms such as Shai-Hulud have shown how quickly a compromised package can spread, and a short delay gives scanners time to catch a bad release. Most package managers now have a minimum release age setting, and teams should configure it in their projects. Safe Chain covers what those settings miss, such as a one-off npx command outside any project, or malicious packages older than the age limit.
Safe Chain covers only two ecosystems, but both have been targets of supply chain attacks. A version blocked for its age produces only a generic notice that packages were suppressed. Teams pulling through a private mirror with its own age limit gain little, and the malware blocking depends on a single vendor's feed. Safe Chain is licensed under the AGPL or a commercial license, so check the terms before building it into anything you distribute.
-
100. Swamp
Swamp is an automation tool built to be used by AI coding agents. When an agent carries out an operational task directly, it may do it differently each time and leave little record of what it did. With Swamp, the agent writes the automation instead, as TypeScript models of external systems and YAML workflows that chain the models' methods together. The workflows follow the same defined process every time, their definitions live in a Git repository and the output from each run is kept as versioned data the agent can query later. Credentials are injected from a vault at runtime, so they stay out of prompts. Models can also be packaged as extensions and shared through a registry. An agent instructed to write and commit scripts without Swamp can produce something similar, but without built-in typed interfaces, run history or reusable modules.
Swamp replaces System Initiative, which we featured in Assess in a previous volume. Swamp grew out of infrastructure management but is aimed at operational workflows more broadly, from incident response to data pipelines. The source is open under AGPLv3, although the official distribution uses a commercial license that requires a subscription for use at work. The project is new and moves fast, with a fresh release for every commit, so teams should try it on low-risk internal automation before depending on it.
-
101. Vale
Vale is a linter for prose. It parses Markdown, AsciiDoc and reStructuredText, skips code blocks and checks the text against style rules stored as YAML in the repository, so writing conventions can be enforced in the editor and in CI, much like code style. Packaged styles cover the Google, Microsoft and Red Hat documentation guides; others check for inclusive language or readability, and you can write your own. Vale has been part of docs-as-code toolchains for years, but the volume of LLM-drafted documentation, ADRs and PR descriptions makes it more relevant now. Packages such as vail-ai-tells flag the phrasing typical of generated text, and Vale works well as one of the feedback sensors for coding agents, allowing an agent to revise a draft before anyone reads it.
Vale's checks are deterministic word and pattern matches, which can catch surface-level habits but miss weak reasoning or invented detail. Vale also depends largely on one maintainer, and our use so far has been by individuals working on their own writing rather than by client teams.
-
102. Varlock
Varlock is an open-source environment configuration and secrets-management layer designed to avoid exposing secrets to coding agents via plaintext. Instead of relying on informal
.env.exampleconventions, Varlock introduces a committed.env.schemathat describes variable names, types, validation rules and documentation. It separates the configuration contract from the actual values. Secrets are resolved and injected at runtime from external vaults such as 1Password, AWS Secrets Manager or Azure Key Vault. For workloads where an agent must call an authenticated service, Varlock also offers a credential proxy that provides a placeholder to the agent and substitutes the real value only at the network boundary. We've found this to be a useful pattern that replaces ad hoc helper scripts and extends secret injection across multiple environments without exposing credentials. -
103. zizmor
zizmor is a static analysis tool for GitHub Actions workflows that also checks Dependabot and pre-commit configurations. It flags misconfigurations attackers can exploit, including template injection, overly broad permissions and actions pinned to mutable tags as well as the use of risky triggers such as pull_request_target. It can also fix some findings automatically.
This year, attackers [exploited a
pull_request_targetworkflow in the Trivy repository, then rewrote the tags of its GitHub Action so pipelines referencing those tags ran the attackers' code. Our teams have used zizmor on client work, running it from the command line and as a pre-commit hook while writing workflows. Coding agents can run it too, providing quick feedback on the pipelines they write.Amid the attention on AI-powered security scanning, we like having a deterministic tool for this job. Snyk and Wiz cover some of the same ground commercially and general linters catch some of these issues, but zizmor is free and open source. Its drawback is scope: it doesn’t cover any other CI platforms beyond GitHub Actions. Teams using GitHub Actions should evaluate zizmor alongside zero trust security for CI/CD.
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.
