HackerNews AI - 2026-08-12¶
1. What People Are Talking About¶
August 12's Hacker News AI feed covered 104 stories from 102 authors, with 705 total points and 350 total comments. That was slightly fewer stories than August 11's 108, but materially more engagement: total points rose from 511 to 705 and comments from 210 to 350. Attention was highly concentrated in one benchmark thread: Grok 4.6 scores 61 on the Artificial Analysis Intelligence Index accounted for 281 points and 268 comments by itself, or about 40% of the day's points and more than three quarters of its comments. Even so, the long tail stayed infrastructure-heavy: 35 stories were Show HNs, 25 stories mentioned Claude Code or Codex, and 16 mentioned MCP.
1.1 Agentic benchmarks became the main way HN compared frontier models and agent stacks (🡕)¶
The biggest discussion was not a raw model release. It was a benchmark interpretation layer plus a fight over what those scores mean in actual coding workflows. August 12's model conversation centered on agentic task performance, turn efficiency, and price-to-output tradeoffs rather than on abstract reasoning claims.
wertyk posted Grok 4.6 scores 61 on the Artificial Analysis Intelligence Index (281 points, 268 comments). The linked Artificial Analysis write-up says Grok 4.6 reached an Intelligence Index score of 61, matched GPT-5.6 Sol, hit 88.4% on Terminal-Bench v2.1, and landed on the cost/performance Pareto frontier at $0.84 per task with unchanged $2/$6 per 1M token pricing. HN immediately translated that into daily-driver judgments rather than benchmark admiration. mpalczewski (score 0) said he had dropped Claude for Grok in personal coding because it was faster and less verbose, while satvikpendem (score 0) said Cursor's Grok-inclusive plans now stretched further than comparable OpenAI or Anthropic usage.
colourclash posted Show HN: I benchmarked my memory graph against Memora (0.831 vs. 0.801) (4 points, 2 comments). The HN post and linked repo argue that Recordari's knowledge-graph memory backend beat Memora's published ICML 2026 result on the LoCoMo benchmark, with a Phase 2 LLM-judge score of 0.831 versus 0.801 and a particularly large gain on multi-session recall at 0.869 versus 0.760. Even at low score, it fit the day's broader pattern: evaluation work was moving beyond "which model is smartest?" toward "which memory layer, harness, or benchmark surface actually improves agent behavior over time?"
Discussion insight: HN treated August 12's benchmark claims as operational procurement signals. People cared about turn counts, cache-read pricing, workflow verbosity, and whether memory systems held up over multi-session tasks, not just leaderboard placement.
Comparison to prior day: August 11 focused on client leaks, pricing pain, and coordination layers. August 12 kept the cost-and-trust framing but routed it through benchmarks and measured subsystem performance.
1.2 Harness-level control, audit, and context tooling thickened into its own product category (🡕)¶
The strongest builder pattern in the long tail was to make agent harnesses smaller, more inspectable, or more measurable. Instead of promising a fully autonomous general agent, these projects narrowed in on transcript visibility, cheaper local execution, assumption tracking, or external auditing.
OleksandrC posted Hax – a minimalist, terminal-native coding agent written in C (72 points, 26 comments). The linked site pitches a single native C binary that keeps memory use to a few megabytes, treats local llama.cpp models as first-class, preserves terminal scrollback, and exposes both transcript view and optional wire traces. The comments reinforced that the value proposition was not "another agent" so much as "a harness you can reason about." abawany (score 0) said he had the tool working with a custom provider in under 10 minutes at roughly one cent of cost, while Bleaphar (score 0) pushed for even more implementation detail.
dimneo posted iFixAi,open-source auditor that checks if your AI agent does its job (4 points, 0 comments). The linked README positions iFixAi as an independent auditing layer that runs 32 inspections across five core pillars, grades agents A through F, and can test either a bare model or a deployed agent over its actual HTTP endpoint. Nearby posts pushed the same control-plane instinct from different angles: Show HN: Aakit – find every assumption your coding agent made, and which broke proposes a way to measure "load-bearing wrong" assumptions on real work, and Show HN: Claude Code kept ignoring our MCP tools, so we used hooks instead points to Graft, a file-backed context layer claiming lower token and tool-call costs for coding agents.
Discussion insight: Low-score builder posts still lined up around the same complaint: agent users do not want more hidden behavior. They want leaner runtimes, explicit traces, scoring layers, and repo-native context that can be inspected or replaced.
Comparison to prior day: August 11's trust discussion was about what mainstream clients were doing behind the scenes. August 12's answer was to ship alternative harnesses and auditors.
1.3 Agents started being treated as first-class actors in labor, identity, and consent flows (🡕)¶
Another clear theme was that builders no longer assume agents only help humans behind the scenes. Several of the day's launches treated the agent itself as the thing searching, applying, spending, or authenticating, which forced trust, consent, and moderation into the core product shape.
fraywing posted Show HN: OJCP – an open protocol for agent-consumable job data (9 points, 0 comments). The HN selftext says today's agents scrape career pages and fight ATS forms with browser automation, while the linked site proposes MCP-native job search and application tools, signed manifests at /.well-known/ojcp.json, normalized apply paths, opt-in candidate data, and trust tiers that cap how much PII an employer or provider can receive. The key claim was not that models would get better at forms. It was that inference alone cannot prove consent or identity, so the protocol has to do that work.
Taskpoolai posted We built a job board where the employers aren't human. Here's what broke (4 points, 4 comments). The post describes a marketplace where agents hire humans through API or MCP access, but the design work went into balance caps, per-agent spending limits, escrowed payments, public and private reputation layers, and human moderation for disputes. The comments immediately tested those edges rather than the novelty. pavel_lishin (score 0) asked how workers actually get paid, which shows how quickly these systems are judged as labor infrastructure instead of demo ware.
Discussion insight: Identity and accountability kept resurfacing around adjacent items too. Show HN: Reallyfrom.me – vouch that your message is from you tried to hash and verify authored messages, while AI agents aren't legally responsible for harm they cause. So who is? linked to a Guardian report arguing that deployers, not agents, remain legally responsible when automated systems cause damage.
Comparison to prior day: August 11 treated identity pages and shared inboxes as agent infrastructure. August 12 pushed the same trust question into hiring, payments, and legal liability.
1.4 Human attention became the binding constraint in AI-native software workflows (🡕)¶
The final strong theme was organizational rather than model-centric: once agents can produce code and documents cheaply, the scarce resource becomes human review time. Several posts focused on how teams are restructuring planning, code review, and explanation surfaces around that bottleneck.
superpickles789 posted Ask HN: What's your team's SDLC look like in this AI world? (4 points, 2 comments). The prompt described an organization where meetings are recorded and transcribed, agents draft PRDs and system design docs, and non-engineers can now commit code, but per-PR environments, capacity planning, and code review have become the new choke points. The top response from knighthacker (score 0) said his team had effectively dropped traditional code review and now reviews the coding session itself through the CLI, which is a concrete shift in what "review" means once agent output volume rises.
juanpflores posted CodeRabbit raises a $143M Series C at a $1.5B valuation (5 points, 1 comment). The linked CodeRabbit post says issue tracking is becoming less central because coding agents can turn requirements, alerts, or support tickets into pull requests directly, and that the new bottleneck is human judgment over which changes deserve attention. A smaller but related response came from dhorthy, whose Show HN: /show-me: agent skill for compact visual representations (5 points, 1 comment) argued that the "wall of prose" problem has become bad enough that coding agents need explicit visual explanation modes.
Discussion insight: The day kept reframing the same problem at different levels: PRs are getting larger, planning can happen after code exists, and even successful agent output now needs better triage, visualization, and reviewer-routing than legacy workflows provide.
Comparison to prior day: August 11 emphasized durable files and handoff state. August 12 emphasized the people who still need to read, prioritize, and approve what those files turn into.
2. What Frustrates People¶
Human review is becoming the real bottleneck¶
superpickles789 posted Ask HN: What's your team's SDLC look like in this AI world? (4 points, 2 comments), and the pain was not "we cannot generate enough code." It was that per-PR test environments are unreliable, capacity planning is getting fuzzy, and code reviews are longer because more people can now summon agent-written changes. The linked CodeRabbit post, attached to CodeRabbit raises a $143M Series C at a $1.5B valuation (5 points, 1 comment), makes the same complaint in product language: implementation is cheap enough that the backlog is moving from tickets to pull requests, while human attention remains finite. Show HN: /show-me: agent skill for compact visual representations (5 points, 1 comment) exists for the same reason at a smaller scale — walls of agent prose are now part of the review tax. Severity: High. Worth building for: yes, directly.
Silent assumptions and self-policing agents still do not inspire trust¶
Abhixhek posted Show HN: Aakit – find every assumption your coding agent made, and which broke (5 points, 0 comments), and the linked README explicitly frames the missing metric as the "load-bearing wrong rate" of silent assumptions on real work. The same frustration showed up more publicly in Coding agents ignore open source contribution guidelines, researchers find (3 points, 0 comments): the linked The New Stack report says agents almost never proactively retrieve contribution rules and still do not refuse to contribute to AI-banned repositories even when prompted. Never Trust Your AI Agent's Own Sandbox (3 points, 0 comments) sharpened the same concern from the operator side: the linked essay argues that a vendor-supplied sandbox still leaves broad read access, tool paths outside the sandbox, and model-controlled retries into dangerous modes. Severity: High. Worth building for: yes, directly.
Access to premium agentic tooling is starting to act like a hiring filter¶
theanonymousone posted Interview questions assume candidates can afford Claude Code Max (5 points, 0 comments), and the linked LeadDev article says some interview loops now ask about the last Claude Code skills a candidate wrote, even though students and job-seekers may not be able to afford comparable tooling or token budgets. The article also reports engineers spending personal money and unpaid time to stay current. The Grok thread added a coping pattern rather than a solution: comments praised cheaper subscription surfaces such as Cursor's Grok-inclusive plans, which means the market is already sorting people by which bundles they can access, not only by skill. Severity: Medium-High. Worth building for: yes, competitively.
Agent-facing marketplaces still lack mature identity, consent, and liability rails¶
fraywing posted Show HN: OJCP – an open protocol for agent-consumable job data (9 points, 0 comments) because today's agents still scrape career sites and guess their way through ATS flows. The proposed fix includes signed manifests, trust tiers, and PII caps because better inference alone does not prove candidate consent. Taskpoolai posted We built a job board where the employers aren't human. Here's what broke (4 points, 4 comments), whose solution was balance caps, escrow, and human dispute moderation. The linked Guardian report behind AI agents aren't legally responsible for harm they cause. So who is? (3 points, 1 comment) pushes the same issue into law, arguing that deployers remain responsible when an agent causes harm. Severity: High. Worth building for: yes, directly.
3. What People Wish Existed¶
Consent-first protocols for agents acting in public systems¶
The cleanest unmet need in the dataset was infrastructure that lets agents search, apply, pay, and authenticate without relying on scraping or vague delegated trust. fraywing posted Show HN: OJCP – an open protocol for agent-consumable job data (9 points, 0 comments), which explicitly says inference cannot establish authorization and therefore needs signed manifests, identity, and scoped consent. Taskpoolai posted We built a job board where the employers aren't human. Here's what broke (4 points, 4 comments), where escrow, agent spending limits, and human dispute resolution had to be designed into the marketplace from day one. kiddz posted Show HN: Reallyfrom.me – vouch that your message is from you (2 points, 3 comments), which treats authorship verification itself as an agent-era requirement. This is a practical need with immediate utility, and the opportunity is direct.
Review and prioritization layers that make AI-generated change legible to humans¶
superpickles789 posted Ask HN: What's your team's SDLC look like in this AI world? (4 points, 2 comments) because the basic workflow question is no longer "can we generate changes?" but "how do we review and route them?" The linked CodeRabbit post behind CodeRabbit raises a $143M Series C at a $1.5B valuation (5 points, 1 comment) argues that PRs are becoming the auditable planning surface once anyone can ask an agent to produce code. dhorthy posted Show HN: /show-me: agent skill for compact visual representations (5 points, 1 comment) because plain-language compression and visual explanation now feel like missing workflow primitives rather than nice-to-haves. This need is practical, urgent for teams already deep into agentic coding, and the opportunity is direct.
Lean harnesses with explicit traces, assumption ledgers, and independent judges¶
OleksandrC posted Hax – a minimalist, terminal-native coding agent written in C (72 points, 26 comments), and its core pitch is that a harness should stay small enough to inspect and cheap enough to run locally. Abhixhek posted Show HN: Aakit – find every assumption your coding agent made, and which broke (5 points, 0 comments), while dimneo posted iFixAi,open-source auditor that checks if your AI agent does its job (4 points, 0 comments). Taken together, these posts say the missing product is not "another smarter wrapper." It is a harness with explicit traces, measurable assumptions, and a judge that sits outside the agent itself. The opportunity is direct and already competitive.
Memory and context systems that stay useful without turning into stale prompt ballast¶
colourclash posted Show HN: I benchmarked my memory graph against Memora (0.831 vs. 0.801) (4 points, 2 comments) because teams want memory systems they can benchmark on real multi-session retrieval instead of trusting vibes. qikouki posted Hybrid-retrieval memory layer for AI agents (4 points, 0 comments), whose linked DeepMem README claims a drop-in Mem0-compatible API with hybrid retrieval and lower cost. Nearby low-score posts such as Why Does Claude.md Keep Growing? Catastrophic Remembering in Agentic Coding and Show HN: Claude Code kept ignoring our MCP tools, so we used hooks instead show the downside of the current state: memory can either disappear too fast or accumulate into noisy context that agents stop using well. The need is practical, and the opportunity is competitive.
4. Tools and Methods in Use¶
| Tool | Category | Sentiment | Strengths | Limitations |
|---|---|---|---|---|
| Grok 4.6 | Frontier model / coding model | (+/-) | Frontier-level agentic benchmark performance, lower headline pricing than nearby rivals, stronger turn efficiency on long-horizon tasks | Cache-read pricing rose, HN trust still depended on real coding experience rather than the leaderboard alone |
| Hax | Coding agent CLI | (+) | Native C binary, low memory footprint, local-model support, transcript and wire-trace visibility, terminal-native UX | Deliberately omits richer plugin and permission layers, so teams needing those features must compose them elsewhere |
| Recordari / locomo-recordari | Memory backend / benchmark harness | (+) | Public LoCoMo benchmark harness, strong multi-session retrieval score, knowledge-graph approach to durable memory | Early evidence mostly comes from one benchmark setup and one project team's usage pattern |
| CodeRabbit | AI code review / change management | (+/-) | Independent review layer, triage, change explainability, continuous monitoring of shipped code | Still assumes PR review can absorb rising agent output volume, and the category is getting crowded fast |
| OJCP | Agent-facing job protocol | (+) | MCP-native tools, signed manifests, normalized apply paths, consent-first privacy, fit-scoring without sending full PII | Requires adoption from employers and providers before it can displace brittle scraping flows |
| Aakit | Assumption measurement kit | (+) | Tries to quantify consequential wrong assumptions, asking policies, and targeted retraction on real workloads | The README is explicit that core publishable numbers mostly do not exist yet |
| iFixAi | Agent auditor | (+) | A-F grading across multiple governance pillars, supports real deployed agents, plugin and CLI entrypoints | Setup and evaluation are heavier than lightweight developer tools, and evidence still depends on fixture quality |
| Graft | Repo context layer | (+) | File-backed code graph, lower token and tool-call claims, repo-native context that agents can inspect as normal files | Requires graph-building and hook wiring, and benchmark claims come from the project's own harness |
| /show-me | Output-formatting skill | (+) | Makes plans, call stacks, and file trees more readable than walls of prose | Improves legibility, not correctness; teams still need separate review and prioritization layers |
Overall satisfaction was highest for tools that made agent work more inspectable or more bounded. Hax, Recordari, Aakit, iFixAi, Graft, and OJCP all earned attention by clarifying a specific control surface: runtime cost, memory quality, assumption tracking, auditability, codebase context, or consent. Mixed sentiment concentrated on tools that still leave humans with the scaling problem after the demo ends. CodeRabbit's own framing says human judgment is now the scarce resource, and Grok's benchmark win still got translated into discussion about verbosity, token bundles, and switching costs.
The common workaround pattern was not "trust the agent more." It was layering: use cheaper or local models where possible, move context into explicit files or graphs, review sessions instead of only diffs, add independent auditors, and put signing or balance caps around any agent allowed to act externally. Competitive pressure is strongest in three zones at once: audit layers, memory/context layers, and PR-triage layers.
5. What People Are Building¶
| Project | Who built it | What it does | Problem it solves | Stack | Stage | Links |
|---|---|---|---|---|---|---|
| Discovered Materials | advaith08 | Uses AI agents to propose semiconductor materials and synthesis recipes for thermal and packaging bottlenecks | Materials discovery is too slow and expensive for rising GPU heat and packaging demands | Web search, Python/bash sandbox, pymatgen, mp_api, ASE, PET-MAD, Pheasy, Phonopy, GMTNet, Inspect | Beta | post, research |
| Hax | OleksandrC | Minimalist terminal-native coding agent with local-model support and transcript visibility | Developers want a smaller, more inspectable harness than mainstream coding clients | C, llama.cpp, OpenAI-compatible providers, Anthropic-compatible providers, transcript and wire traces | Beta | post, site |
| OJCP | fraywing | Open protocol and MCP tool surface for agent-readable job search and job application flows | Agents currently scrape career sites and cannot prove consent or identity cleanly | MCP tools, signed manifests, schema.org extensions, WebMCP, fit scoring, scoped PII controls | Beta | post, site |
| Taskpool | Taskpoolai | Marketplace where agents hire humans for real-world help and manage projects over API or MCP | Autonomous agents still need human labor, but standard marketplaces assume humans on both sides | API, MCP, webhook notifiers, spending limits, escrow, moderation | Shipped | post, site |
| Recordari / locomo-recordari | colourclash | Knowledge-graph memory backend and benchmark harness for long-conversation recall | Teams need durable memory that survives multi-session work and can be measured against a public benchmark | Knowledge graph API, LoCoMo harness, LLM extraction, MCP-compatible memory service | Alpha | post, repo |
| Personal Jarvis | PersonalJarvis | Voice-driven orchestrator that can run shell commands, operate the computer, route to coding agents, and remember context | Existing voice assistants talk back instead of actually coordinating work across tools and agents | Python, MCP, coding-agent workers, local STT/TTS options, multi-provider model routing | Beta | post, repo |
| Bough | alukin | Coding harness where the model writes one JavaScript program per turn instead of single tool calls | Tool-by-tool round trips make agent execution brittle and constrain real control flow | JavaScript programs, server-owned state, subagents, workflows, shared checkout | Alpha | post, repo |
Discovered Materials was the clearest "AI beyond software tooling" launch. Its argument was not that language models can magically replace materials scientists. It was that agents with web search, scientific tooling, and grading loops may reduce the number of experimental iterations needed to find viable semiconductor materials, especially around GPU thermal bottlenecks and 3D packaging.
OJCP and Taskpool pointed to the same new build pattern from different sides: the agent is no longer only an assistant inside a coding session. It is becoming a participant in labor and application markets. That forced both products to build trust rails first — manifests, signatures, spending caps, escrow, and moderation — because those systems break immediately if identity and consent stay implicit.
Hax, Bough, Recordari, and Personal Jarvis all attacked the harness layer rather than the frontier-model layer. Hax competed on inspectability and local runtime weight, Bough on richer per-turn control flow, Recordari on measurable long-term memory, and Personal Jarvis on voice-driven orchestration across shell, MCP, and coding-agent workers. The common trigger was not "we need one more general agent." It was that current harnesses are still too opaque, too stateless, or too awkward to coordinate.
6. New and Notable¶
One benchmark digest absorbed most of the day's community attention¶
wertyk posted Grok 4.6 scores 61 on the Artificial Analysis Intelligence Index (281 points, 268 comments). The notable part is not only that Grok 4.6 benchmarked well. It is that one third-party evaluation write-up captured roughly 40% of the day's total points and more than 75% of its comments, which shows how strongly HN is now using agentic benchmark summaries as a market signal for which coding stack to try next.
Builder energy stayed high, but the mix shifted from demos toward operational plumbing¶
August 12 still had 35 Show HN posts out of 104 stories total, even after August 11's unusually high 50. The distinctive shift was that the launches clustered around harnesses, audits, memory, and protocols instead of around a single breakout app: Hax – a minimalist, terminal-native coding agent written in C (72 points, 26 comments), Show HN: OJCP – an open protocol for agent-consumable job data (9 points, 0 comments), Show HN: I benchmarked my memory graph against Memora (0.831 vs. 0.801) (4 points, 2 comments), and iFixAi,open-source auditor that checks if your AI agent does its job (4 points, 0 comments) all fit that pattern.
Agent participation in labor markets stopped sounding hypothetical¶
fraywing posted Show HN: OJCP – an open protocol for agent-consumable job data (9 points, 0 comments), while Taskpoolai posted We built a job board where the employers aren't human. Here's what broke (4 points, 4 comments). The notable signal was not scale. It was that both projects immediately had to solve trust, consent, payment, and moderation problems that only appear once agents are treated as actual market participants.
Agent fluency started surfacing as a labor-market credential¶
theanonymousone posted Interview questions assume candidates can afford Claude Code Max (5 points, 0 comments). The notable part of the linked LeadDev article is that it frames access to leading agentic tools and practice time as a hiring filter already shaping interview questions, intern decisions, and personal spending.
7. Where the Opportunities Are¶
[+++] Independent audit and control layers for coding agents - Hax – a minimalist, terminal-native coding agent written in C (72 points, 26 comments), Show HN: Aakit – find every assumption your coding agent made, and which broke (5 points, 0 comments), iFixAi,open-source auditor that checks if your AI agent does its job (4 points, 0 comments), and Never Trust Your AI Agent's Own Sandbox (3 points, 0 comments) all point to the same gap. Users want visible traces, assumption ledgers, external scorecards, and stronger boundaries because they do not trust self-policing agents to reveal their own failure modes.
[+++] Agent-facing transaction, hiring, and identity infrastructure - Show HN: OJCP – an open protocol for agent-consumable job data (9 points, 0 comments), We built a job board where the employers aren't human. Here's what broke (4 points, 4 comments), Show HN: Reallyfrom.me – vouch that your message is from you (2 points, 3 comments), and AI agents aren't legally responsible for harm they cause. So who is? (3 points, 1 comment) all show the same need: agents are beginning to act in labor and communication systems that still assume human identity, explicit consent, and human liability. This is a strong opportunity because the design constraints are concrete already.
[++] Review, triage, and explanation surfaces for AI-generated change - Ask HN: What's your team's SDLC look like in this AI world? (4 points, 2 comments), CodeRabbit raises a $143M Series C at a $1.5B valuation (5 points, 1 comment), and Show HN: /show-me: agent skill for compact visual representations (5 points, 1 comment) all say that cheap generation has made human judgment the scarce input. The opportunity is moderate-to-strong because the pain is obvious, but multiple teams are already racing into the space.
[++] Measured memory and repo-context infrastructure - Show HN: I benchmarked my memory graph against Memora (0.831 vs. 0.801) (4 points, 2 comments), Hybrid-retrieval memory layer for AI agents (4 points, 0 comments), and Show HN: Claude Code kept ignoring our MCP tools, so we used hooks instead (3 points, 0 comments) all point to demand for memory and codebase context that is durable, benchmarkable, and cheaper than constant re-exploration. The opportunity is moderate because the need is clear, but builders are converging quickly on overlapping designs.
[+] Lower-cost access paths to agent fluency - Interview questions assume candidates can afford Claude Code Max (5 points, 0 comments), ChatGPT and Codex desktop apps now support Linux (4 points, 0 comments), and the Grok thread's discussion of cheaper model bundles all suggest an emerging gap around affordable practice and daily-use access. The need is real, but it is still early enough that distribution, bundling, and local-model quality may matter as much as the product surface itself.
8. Takeaways¶
- HN is increasingly using agentic benchmark write-ups as purchase and switching guides. The Grok 4.6 thread alone accounted for 281 points and 268 comments, and the discussion immediately converted benchmark results into decisions about verbosity, speed, token pricing, and which coding stack to use next. (source)
- The harness is becoming as important as the model. Hax, iFixAi, Aakit, Graft, and Bough all competed on inspectability, control flow, or measurement rather than on frontier-model access alone. (source)
- Agents are starting to be designed as market participants, not just assistants. OJCP and Taskpool both had to build explicit trust rails for applications, payments, and moderation because the agent itself is now the thing acting in the workflow. (source)
- Human judgment is now the scarcest resource in AI-native software teams. The Ask HN SDLC thread, CodeRabbit's "Agentic Change Management" framing, and the
/show-meskill all point to the same reality: generation is cheap, but review, routing, and explanation are not. (source) - Access to strong agentic tooling is already turning into a social and hiring divide. The LeadDev-linked HN post says interviewers now ask about agentic workflows that some candidates cannot afford to practice with, which makes tool access part of labor-market competitiveness. (source)