Feed aggregator

Article URL: https://genception.github.io/

Comments URL: https://news.ycombinator.com/item?id=48936391

Points: 1

# Comments: 0

GUI disk analyzers are great for figuring out what's filling up your laptop/desktop drive.

On containers or remote servers, the options are limited to purely text based utilities (e.g. du) or list-centric TUIs (e.g. ncdu) which are usually limited to viewing one directory at a time.

I created leaves to fill that gap.

Inspired by classic utilities like WinDirStat and KDirStat, it uses a 2-dimensional treemap^1 visualization to show the entire directory hierarchy with proportionally sized rectangles.

It's performant enough to handle millions of files, thanks to Rust and multi-threading. However, block characters aren't as suited as pixels for resolving a large number of items. Leaves can show file-type summaries per directory or partition the top-level directories by extension, allowing you to see not only where space is being used, but also how.

For instance, I can see the largest chunk of my home directory is taken up by uv caches for python and old Linux ISOs that I could easily re-download if needed. Or in a particular container, +600MB is used by standard Rust documentation and tutorials, and that it is the only location with HTML/JS files, when only the libraries and build tools are needed (note to self: remember to use the minimal profile next time).

^1: https://github.com/shundhammer/qdirstat/blob/master/doc/Tree...

Comments URL: https://news.ycombinator.com/item?id=48936389

Points: 1

# Comments: 0

Article URL: https://medium.com/@datavector/nasa-never-said-sanskrit-was-the-best-programming-language-7d08d7e9f53d

Comments URL: https://news.ycombinator.com/item?id=48936387

Points: 1

# Comments: 0

Hey HN, we’re Xia and Varun, the founders of Traceforce (https://www.traceforce.ai/). Traceforce provides visibility and control over AI apps such as ChatGPT, Claude etc directly on all devices (laptops, sandboxes, virtual machines) by discovering not just which apps are being used but also how they are connected to other data sources via MCPs. We also have an open-source dynamic MCP pentesting tool https://github.com/traceforce/mcp-xray to detect vulnerable MCPs.

The purpose of Traceforce is to: 1. Give a company’s employees a standardized way to ensure that AI software running on their device is operating safely 2. Give the company’s security team visibility of the activities of AI software on the company’s devices, and to detect and prevent unsafe actions and security breaches as early as possible.

How Traceforce works 1. Traceforce is installed on each device as a lightweight binary and browser extension. 2. Within 30 minutes, the device is uploading live data to the company profile, displaying all the AI agents/apps running across all company devices on a dashboard. 3. Company security staff can monitor the activity of all the agents in real time, implement controls, and be alerted to any security risks as soon as they appear.

Here’s the video demo: https://youtu.be/IdK2WKg7kaM

The inspiration for Traceforce came via Xia’s experience as Director of Engineering at a startup called Clumio (which was acquired by Commvault in Oct 2024). Being able to monitor how team members are using AI without slowing them down was a top priority at Clumio. After speaking with 50+ CISOs and CIOs, it became clear that this is a much-needed solution right now across industries. We keep hearing that new AI features are being adopted so quickly and so broadly that visibility and control just can't keep up.

Traceforce is transparent about what we monitor and collect. By default, Traceforce collects only metadata and telemetry about the AI applications, MCPs, and tools running on a device. Security teams can enable options to inspect tool calls for the purpose of detecting, warning on, or blocking predefined high-risk or potentially destructive actions. All content inspection happens locally on the device. User prompts are never stored unless explicitly configured by the organization's security administrators.

We work closely with end-users of the product, and once they understand what is being monitored/shared, they actually have great comfort that they have a powerful layer of protection on their device to prevent security incidents. It enables them to just focus on their work without worrying about what leaks and breaches may be happening under the hood without their awareness.

Traceforce is currently deployed across more than 1,000 devices at 10 organizations. On average, we discover over 15 AI applications per device with each application connected to 5-10 MCPs. We've helped customers identify exposed plaintext secrets in MCP configurations, prevent API keys from leaking through AI-generated code, and warn developers before executing potentially destructive commands such as “DROP TABLE”. Our "warn and acknowledge" approach has been especially well received, giving developers the freedom to work while helping them avoid costly mistakes.

We're looking to work with security, IT, and AI platform teams at small to medium enterprises (200+ employees) that are rapidly adopting AI coding assistants, ChatGPT, Claude, and MCPs. If you're struggling to understand what AI tools people use to boost their productivity or need a practical way to reduce AI-related security risk without slowing folks down, we'd love to talk.

You can get started with a free trial at https://www.traceforce.ai or reach out directly to schedule a demo and discuss your environment. Finally pricing is per device, but the exact amount is still TBD. Currently we are thinking $15/month per device but that may change.

Comments URL: https://news.ycombinator.com/item?id=48936384

Points: 1

# Comments: 0

Get everything out of your head, shape it when you're ready, and find it when it matters. Dotflowy is a calm, fast outliner that keeps up with the way you think. Created in the likeness of Workflowy but with the plugin extensibility of Obsidian and the beauty of Linear. MCP compatible.

invite code: "jesus-saves"

Comments URL: https://news.ycombinator.com/item?id=48936366

Points: 1

# Comments: 0

Article URL: https://www.economist.com/science-and-technology/2026/07/15/the-rate-at-which-earth-is-absorbing-energy-is-alarming-climate-scientists

Comments URL: https://news.ycombinator.com/item?id=48936348

Points: 1

# Comments: 1

Everything we've heard about what the new Pixel 11 phones look like, new prices and more storage than last year.

In this article

1. Real-world scenarios
2. Best Practices: Identity + RBAC + Scope + Safe Tool Binding
3. Looking Ahead

AI agents aren’t only smarter API callers. They plan, chain actions across systems, and invoke tools in sequences while no single human explicitly approves each step. The architectural reality may introduce identity and authorization challenges that organizations are still evolving to address.

When an agent operates without a managed identity and least-privilege role-based access controls (RBAC), it can access or modify sensitive data beyond intended permissions if controls are not properly configured. Since agents can operate across multiple systems within a single workflow, a misconfigured permission may increase the potential impact compared to traditional service account scenarios, depending on how the system is configured and scoped. Organizations are deploying agentic capabilities (multi-step automation, delegated actions, tool use) faster than their identity and authorization models are evolving to safely constrain them.  

The resulting exposure can be significant and may include risks such as unauthorized data access, unintended writes or deletions, and potential privilege escalation arising from overly broad role assignments. In some cases, these conditions can also contribute to gaps in auditability, which may make cyberattack detection, incident response, and regulatory inquiries more complex than necessary.

The right mental model is to treat every agent as a first-class principal: give it a lifecycle-managed identity, assign explicit roles, scope its permissions tightly, and scope tool usage to a preconfigured tools manifest or configuration. 

Real-world scenarios

The risk can occur in real-world implementations. Consider a common pattern: a team provisions an agent with a broad “Reader” role because it’s quick and the initial use case seems read-only. Then the workflow expands to include fixing issues it finds, and suddenly the agent needs write access too. Rather than rethinking the role design, teams grant something broader than intended and move on.

The scope creep is quiet, incremental, and rarely revisited. A related problem emerges when agents work across multiple tools. An agent with access to email, files, a ticketing system, and a code repository may look low-risk at each individual integration, but the combination lets it correlate data across systems and take actions no one explicitly authorized as a whole. Combined access across systems may result in broader effective permissions than evaluated individually.

Underneath both scenarios is a question that teams consistently fail to answer cleanly: is the agent acting under its own identity, a delegated user scope, or some mix of both? That ambiguity matters because it determines who’s accountable when something goes wrong, and what approvals were actually required.

When the answer isn’t documented and enforced upfront, it shows up later in the worst possible context: an incident where logs might capture what tool was called but can’t answer key questions such as: who authorized the action, under what role, or whether it was within intended scope. Sensitive data may be retrieved or summarized beyond its intended audiences if controls are not properly scoped.

An agent helpfully automates a remediation step and modifies or deletes something it shouldn’t have. Then the investigation stalls not because logs are missing, but because the identity model was never coherent enough to make them meaningful. This leaves organizations in the firefighting mood to resolve and solve questions their leadership cannot fully answer to customers, press, or auditors.

Best Practices: Identity + RBAC + Scope + Safe Tool Binding

For best practices in designing agentic identity and authorization, implementing multiple controls is intended to help reduce the potential impact of agent actions when configured and applied appropriately, while helping make privilege decisions explicit and supporting accountability in the event of unexpected or unintended outcomes.

Recommended practices for teams are generally to establish and document:

(1) a unique, dedicated agent principal with a named owner and an explicit purpose

(2) least-privilege, task-based roles that are scoped to the specific resources and data the agent needs

(3) Controlled tool access intended to limit the agent to approved actions

(4) end-to-end auditability so you can answer “what happened, under what authority, and what changed?” quickly.

In practice, the time-limited aspect should typically apply to entitlements (role activation, tokens, or approvals) rather than trying to create a new identity for every task. Most real-world deployments keep the agent identity stable for lifecycle management, while using just-in-time (JIT) elevation to grant narrowly scoped privileges only for the duration of a specific workflow.

Start by making the agent afirst-class principal. Create a dedicated agent identity (not a shared secret or reused service account), document its purpose statement (“what it is allowed to do and why”), and assign clear human ownership for approvals and incident response.

Build in lifecycle management from day one: onboarding checks, credential rotation, suspension/decommissioning procedures, and a fast shutdown mechanism that actually invalidates credentials and tokens. Then design role-based access controls (RBAC) around discrete tasks, not teams or org charts.

Model roles that match the smallest meaningful units of work, such as “Read-only knowledge retrieval,” “Summarize labeled documents,” “Create a draft ticket.” Avoid bundling unrelated permissions to reduce operational friction. When the workflow includes both evidence gathering and remediation, separate duties: use different roles (or different tools) for read versus write, and gate high-impact actions like delete, export, or privilege changes behind step-up approvals.

Scope everything and do it multiple times. Constrain permissions by resource boundary (tenant/subscription/workspace/site), by data boundary (collection, label, sensitivity), and by operation boundary (read/write/export/admin).  

The goal is to help make the where and what of access as explicit as the who. Pair this with safe tool binding by exposing a curated and approved set of tools/actions to the agent, and require explicit allowlists for high-impact operations.

This is where JIT for agents can help manage privilege exposure when implemented appropriately, such as, keep the baseline role minimal, use time-limited entitlements (temporary role activation, short-lived tokens, or per-action approvals) when the workflow genuinely requires higher privilege—and automatically drop back to the baseline when the workflow completes.

Finally, design systems to verify explicitly at every step whenever feasible. Downstream tools and services must re-check claims, roles, and scope on each call rather than trusting the orchestrator implicitly; otherwise, the “weakest link” becomes any integration that assumes upstream validation is sufficient.

Consider incorporating accountability controls as a core product feature, not an afterthought. Instrument agent actions end-to-end so logs capture the agent identity, role used, effective scope, resource accessed, action taken, “on behalf of” user (if applicable), timestamps, and correlation IDs that stitch together orchestrator → tool call → downstream system.

Without those fields, teams can’t reliably reconstruct intent or containment boundaries during an incident. Build and test revocation and recovery paths the same way you test feature reliability: practice disabling the agent identity, rotating credentials, and executing rollback/compensating actions for common failure cases (e.g., bulk ticket creation gone wrong, unintended writes, or export attempts). Operationalize governance with regular access reviews, removal of stale permissions, and mandatory re-approval when workflows change materially. And don’t stop at individual roles—deploy tools and processes that analyze aggregate permissions, because the real risk often emerges when multiple “reasonable” roles combine to enable a high-impact chain of actions.

Common pitfalls tend to undermine these controls in predictable ways. The fastest way to create long-term risk is granting broad Owner/Admin roles to unblock a pilot, then never coming back to refactor permissions once the workflow “works.” Shared secrets across multiple agents erase accountability and make revocation slow and incomplete.

Relying on prompts or “the agent will only do X” narratives instead of hard authorization boundaries invites prompt injection and workflow drift. Without the underlying tool invocations, scopes, and downstream authorization decisions, logging only the LLM response creates an audit trail that looks present but is useless for forensics.

Temporary access that lacks an expiry mechanism becomes permanent access in practice. Teams can avoid these anti-patterns by defaulting to task-based roles, enforcing explicit scopes and tool allowlists, using JIT time-limited entitlements for elevation, re-checking authorization in every downstream system, and treating access review and revocation testing as required operational hygiene—not optional maturity work.

Looking Ahead

Agents are quickly moving from helpers to autonomous actors across email, files, tickets, and cloud resources; driving tighter coupling between identity governance, fine-grained authorization, and tool/action policy.

In the next 30–90 days, inventory your agent identities, remove broad roles, introduce task-scoped RBAC, and require safe tool binding plus end-to-end audit logs (with monitoring) before expanding deployments—especially for cross-tenant/guest agents, B2C agents, and agent ecosystems.

Read the Pattern & Practice (PnP): Least Privilege for Agents and use it as a checklist to close the gaps that most reduce impact: ownership, scope, tool allowlists, and fast revocation. 

The post Least privilege for AI agents: Identity, access, and tool binding appeared first on Microsoft Security Blog.

Article URL: https://snippai.dev

Comments URL: https://news.ycombinator.com/item?id=48936307

Points: 1

# Comments: 1

Article URL: https://webbynode.com/articles/akamai-changed-how-it-bills-new-compute-this-month-july-2026-heres-what-that-meant-for-our-dataset

Comments URL: https://news.ycombinator.com/item?id=48936302

Points: 1

# Comments: 0

Article URL: https://imrannazar.com/articles/c64-pongwars

Comments URL: https://news.ycombinator.com/item?id=48936299

Points: 1

# Comments: 1

Article URL: https://slashfriends.org/

Comments URL: https://news.ycombinator.com/item?id=48936250

Points: 1

# Comments: 0

Article URL: https://twitter.com/ab44997/status/2077782776275718429

Comments URL: https://news.ycombinator.com/item?id=48936239

Points: 1

# Comments: 1

We just open sourced a first class our AI web app builder.

Instead of using another hosted AI coding platform, you can fork this project and build your own AI app builder, fully customized and running under your own brand.

It includes:

Next.js + TypeScript AI chat with streaming Artifact generation File explorer Code editor Live preview Databases Sandboxes to be used by AI agents Versions Responsive production-ready UI And a lot more...

The only required dependency is the Totalum API, which exposes the AI generation engine through a simple REST API. You can replace or extend the backend however you want.

It's designed for developers, SaaS companies and agencies that want to:

Build their own AI app builder Add AI app generation to an existing product Create a white label AI builder Customize every part of the UI and workflow Self host the frontend

We use the same frontend in production, and decided to open source it so others don't have to start from scratch.

Repository: https://github.com/totalumlabs/ai-app-builder-open

I'd love feedback, feature requests, or ideas from the HN community.

Comments URL: https://news.ycombinator.com/item?id=48936225

Points: 1

# Comments: 0

Article URL: https://github.com/chattymin/PokeTokenBar

Comments URL: https://news.ycombinator.com/item?id=48936171

Points: 1

# Comments: 1

Article URL: https://chipmotors.com/

Comments URL: https://news.ycombinator.com/item?id=48936155

Points: 1

# Comments: 0

Article URL: https://localghost.dev/blog/everything-i-googled-in-a-week-as-a-professional-software-engineer/

Comments URL: https://news.ycombinator.com/item?id=48936143

Points: 1

# Comments: 0

Legacy systems, safety concerns, and critical infrastructure risks make OT vulnerability disclosure one of cybersecurity's most challenging balancing acts.

The post Legacy Systems, Real-World Impacts: The Reality of OT Security appeared first on SecurityWeek.

European authorities dismantled the VPN service in May following a yearslong investigation.