Hacker News

https://pomerado.ai/). We connect your agents to any website by turning sites into deterministic, self-healing APIs in minutes, fully self-serve.

Agents are no longer limited by their intelligence, but rather by their ability to interact with systems. Airlines, banks, e-commerce, insurance portals, government sites, and legacy portals all lack APIs or MCPs and are common parts of personal assistant or business workflows. Agents instead rely on browser automation or computer use, which can be slow, expensive, and unreliable. And even if computer use were perfect, most companies have banned it out of security and compliance concerns.

We discovered this problem while tinkering with our own personal assistants. When OpenClaw came out, we wanted to “live our lives through our agents” and have them do everything for us. We soon found their usefulness was restricted by what tools they could connect to. For example, when trying to book flights, they fell back on computer use, which failed to checkout. These issues got magnified on repeated workflows, like searching many airlines at once.

Pomerado started off as a project to improve these personal assistant workflows. As we started building, we realized that just-in-time tool creation could have significant applications for AI builders in legacy verticals.

We’re ex-McKinsey and Scale AI, where we drove agent deployments in healthcare, professional services, and telecom. Each time, the biggest bottleneck was getting agents to interface well with legacy websites and apps.

Pomerado is what we built. It’s a self-serve platform where devs can create APIs for any website (even those they don’t own), in minutes. Users (or their coding agents) provide a short natural language description, answer a few questions about their workflow, and receive a MCP in less than an hour. Future tool calls use the deterministic MCP, which usually returns results in 5-30 seconds.

Here’s a walkthrough of our product: https://youtu.be/Bi4jci7rgHo

In practice:

- Our agent opens a browser, explores the website, and performs the requested task once by writing HTTP requests or a Playwright script. This example run establishes how to navigate the website, interact with the relevant controls, and obtain the desired result. If any additional user input is needed (e.g., login, clarification) the agent will ask the user over MCP.

- Afterwards, the agent uses the example run, along with all of the data it recorded, to create a generalizable and repeatable API. Throughout this process, a separate Guardian model reviews the coding agent’s calls against a set of guardrails. We also run a battery of tests with synthetic inputs to ensure that the API is generalized and not overfit to one input. A final publication agent ensures that the integration publishes a reasonable and generalized input/output schema

- We also handle sites that require authentication and 2FA. For authentication, we pass off to a deterministic sign-in process to ensure the model and our recorders never read customer credentials. Users can store 2FA TOTP seeds or link their account to a Pomerado phone number for us to autofill 2FA for them as well

- If future runs fail, a maintenance job is kicked off to repair and improve the tool. The maintenance job can fix broken steps (e.g., a renamed button), add additional functionality (e.g., searching for business class flights in addition to economy), or add new guardrails (e.g., reservation dates must be in the future). We’ve even seen people improve tools by just saying “please make this faster”

Unlike computer use, our MCPs are deterministic at runtime, which makes them much faster and cheaper. By taking slightly longer to do a task the first time, you reap the benefits much more in the future. It’s a great fit for repeated, high-volume tasks you want your agent to do.

We’d love to have you try it! We have both an open-source (MIT) (https://github.com/Pomerado/pomerado) and a free hosted version (https://app.pomerado.ai).

So far, users of Pomerado include:

- A personal trainer using agents to prepare workouts and message clients. Before Pomerado, agents couldn’t login and use the site reliably, so this was all manual

- Car dealerships connecting their Grok Bots to legacy dealer systems, including marketplaces, CRMs, and ERPs. Dealers switched from computer use, which could take 1hr+

- Personal assistants using Pomerado to integrate with a broad range of consumer websites

Please ask any questions or share any feedback in the comments, thanks!

I was looking for an application that would allow me to ask an agent to make a first draft of whatever art I needed with actual brushes, and then be able to go in myself and edit every last stroke or layer that it created.

Klad is that application. Written in Rust, it can be fully controlled by an agent through the CLI, and every function is available in a nice UI as well: a brush engine, frame-by-frame animation (and bones/IK), vectors, text layers, colours, layer effects, infinite undo (even after re-opening the file!),…

Why I think it's useful for a wider audience: Adobe showed agents editing Photoshop files at MAX this week, with a private beta planned for early 2027.

Klad is built on the same core idea, with editable paint strokes as core architecture, and it works today.

Clone the repo to try it out: https://github.com/klad-app/klad

You can basically point Claude to the repo, ask it to build it, and pick up the drawing skills. Then ask it to make any drawing you want! (After that, you or the agent can change absolutely every brush stroke in the app again, which makes edits a breeze.)

The quality of the drawings really depends on the agent you use. I have tried it with Claude Fable 5.2 since it came out on Monday, and the drawings are already quite impressive. I'm confident that this will only improve.

I use it every day on Mac, so that definitely works well. It builds on Linux too (tablet pen pressure still needs some work there). Windows builds in CI, I haven't used it there myself yet but I have some reports that it works perfectly fine.

Coming up next is support for pixel art. I'm in the testing phase with this right now, and I expect it to go live in the repo sometime this weekend.

Klad is source-available rather than open source: free to build and use for individuals and small companies, and I plan to sell pre-built binaries later, the way Aseprite does. The file format, CLI reference and agent skill are MIT.

What I want to hear from people who try it: Can your agent work out the CLI without help, and where does it get confused? Can you go in and change one of its strokes easily?

The command reference and guides are available at https://klad.studio

I'll be here answering any questions about the technical side as well, as it's a pretty interesting challenge to build a performant engine with editable brush strokes that render as paint.

Similar to Granola, Yogurt runs in the background and does not join your calls. But unlike Granola, Yogurt is open-source, free to use, and private. Your meeting transcripts, call recordings, and summaries never leave your computer.

As small OSS models have gotten faster and more powerful, Yogurt seemed like a pretty obvious win for privacy and cost conscious folks. You do not need a frontier model to summarize meeting notes or answer questions about them. And if you want to make your notes available to a frontier model, you can just share it with Anthropic, OpenAI, etc. directly via Yogurt’s local MCP server. There’s no need to use a paid cloud service as a middleman.

I tried some of the most popular OSS note taking tools, and most were missing features like calendar integration, MCP server, etc. or required you to connect or create an account. And more than that, they didn’t feel polished enough for it to be something I actually wanted to use daily, and so I built Yogurt to scratch that itch. I spent a lot of time fine-tuning every UI interaction/animation and optimizing the model calls to get the most out of your hardware + make it snappy.

To support Windows/Mac/Linux, I decided to go with Electron. I use whisper.cpp for transcription and Apple’s on-device SpeechAnalyzer if your system supports it. For call summaries and questions, I use a local open weight LLM that automatically gets downloaded and set up based on what your hardware can handle without your cooling fans firing off like crazy (this part uses llama.cpp).

I’ve spent a lot of time working on details like echo detection/reduction, global/folder/local level search respectively, and auto-end recordings. Hope this is useful for any of you who have held out on using AI note tools for privacy or cost reasons, or for folks using cloud tools who want to switch to something free and open source that still feels great to use.

Would love to hear what you think about the onboarding and note taking experience :)

No internet connection needed. Uses a locally-installed compiler for assembly generation.

Tinfoil: https://tinfoil.sh/ is a security research lab building an AI cloud for private, verifiable computation. Our customers include DuckDuckGo, Mozilla, financial institutions, AI labs and startups. Frontier labs, Google Deepmind, Trail of Bits, Redhat and Canonical, have also used us for research.

As attacks on infrastructure grow more powerful, our goal is to bring state-of-the-art defenses to individuals and organizations as quickly as possible, without making them trade away performance or ease of use. Our mission[1] is to create a private garden for thought, where people keep control of their own agency, and we keep evolving our research[2] to stay ahead of rapidly changing threat models.

About this role

As an Applied AI Security Engineer, you’ll help companies deploy AI on Tinfoil when security or privacy is a hard requirement. Our customers include enterprises in regulated industries, AI labs and startups that need secure compute, and privacy-first product companies. You’ll partner with Sales to guide strategic customers from technical discovery through deployment. Then you’ll bring what you learn back to Product, Engineering, and Research so that what we build next reflects what customers need. The role is equal parts product engineer, security advisor, field expert, and connective tissue.

This role is based in our San Francisco office, in person at least 3 days a week.

With customers, you’ll become a trusted technical advisor. You’ll turn their threat models and privacy requirements into a working architecture, and show them how to verify Tinfoil’s guarantees themselves. You will help strategic customers understand the value of Tinfoil and paint the vision on how they can successfully integrate and deploy Tinfoil into their technology stack. When they hit problems, you’ll get hands-on: reproducing their environment, digging into the issue, and building working solutions with them.

With product, you’ll get involved early to build deep expertise on new capabilities as they develop. You’ll help test new products to understand their strengths and limitations, and build demos for public or customer-facing use. And throughout, you'll help shape our roadmap by synthesizing what you're learning across customers and products into clear signal about what’s working, what isn’t, and what matters most.

To succeed, you’ll need the technical depth to push the limits of what Tinfoil can do and a strong understanding of our product and security model. You’ll also need to explain complex capabilities clearly to many different audiences in a world where threat models keep changing.

Responsibilities:

1. Serve as the primary technical advisor to strategic customers from discovery through production deployment, working across Sales, Product, Engineering, and Research to make them successful

2. Turn each customer’s threat model and security or privacy requirements into a deployment architecture built on Tinfoil

3. Build pilots, prototypes, and eval suites that prove Tinfoil meets a customer’s performance and security bar

4. Lead architecture and security reviews with the customer’s engineering, security, and compliance teams, including showing them how to verify Tinfoil’s guarantees themselves

5. Get hands-on when customers hit new problems: reproduce their environment, find a solution, and turn it into an approach other customers can reuse

6. Create reference architectures, playbooks, and public content (blogs, talks) and talks at conferences on deploying AI with high-assurance security

7. Find patterns across customers (adoption blockers, capability gaps, compliance needs) and work with Product and Research to get them on the roadmap

8. Travel occasionally to customer sites for workshops and implementation support

You may be a good fit if you have:

1. 2+ years of experience in technical roles such as software engineer, forward deployed engineer, security engineer or technical product manager, with a desire to work closely with customers. Former technical founders are also encouraged to apply.

2. Strong programming skills in Python or TypeScript and experience building production applications.

3. A solid background in security, networking, or infrastructure, and comfort explaining threat models and security guarantees to skeptical audiences.

4. Hands-on experience building with LLMs, such as agents, workflows, or LLM-powered products, including designing evals and prototypes.

5. Strong communication skills: you can explain complex technical and security concepts clearly to founders, engineers, security and compliance teams, and executives, with a low ego and a collaborative approach.

6. A track record of going deep on technical problems and turning what you learned into materials, tools, or training that helped others succeed.

7. The ability to quickly build expertise in new domains and work through ambiguity, finding simple solutions to complex problems

8. Passion for building AI systems with privacy, verifiability, and control as core properties

Bonus:

1. Experience with applied cryptography or hardware security

2. Experience deploying software in regulated industries (finance, cybersecurity, government, biotech) or guiding customers through security reviews

3. Experience with model serving or inference infrastructure

4. Public technical writing or speaking

We encourage you to apply even if you don’t meet every single qualification!

If this sounds like a good fit, please reach out to work@tinfoil.sh or apply here: https://tinfoil.sh/join.

[1] https://tinfoil.sh/mission [2] https://tinfoil.sh/blog

https://www.reddit.com/r/Python/s/2Cm5dBcvQw

https://blue-continuum.com/hooked-on-tuna

Micron is not my first langage design. I first built Oberon+, a modernized and unified Oberon, in order to under­ stand, by implementing it and by porting real systems to it, what Wirth’s design actually gives and where it fails. The systems ported to Oberon+ included the 2013 Project Oberon System and different versions of Oberon System 3. I then explored the opposite direction with Luon, a higher-level language for managed application progamming. Micron is the synthesis of this and my 30 years experience with C/C++ in systems programming.

The goal of Micron is to use the same language for boot code, device drivers, an operating system kernel, and ordinary applications, without requiring a garbage collector or routing machine access through a separate, unchecked system dialect (such as Oberon's SYSTEM.ADR/GET/PUT which operates on LONGINT). The language supports explicit memory layouts, signed and unsigned integer types, pointer operations, and direct calls to C without wrappers. One of its central design choices is language levels. Each module declars the level and thus the feature it needs, ranging from code that requires neither stack nor heap to garbage-collected objects. A module can import only modules at the same or a lower level. For example, a kernel module declared at level 1 cannot accidentally acquire a dependency on heap allocation through an import. Other features include generic modules, structural interfaces, and compile-time procedures. Much of what would require a preprocessor in C is expressed through typed language features.

There is a working compiler, interpreter, and IDE, along with a free textbook (http://software.rochus-keller.ch/micron-textbook.pdf). The book explains both how the language works and the reasons behind its design. Its systems-programming section walks through a port of Wirth and Gutknecht’s Project Oberon operating system to Micron, cross-compiled and linked into a single executabl that runs on an emulated RISC-V machine.

The examples also include ports of a Smalltalk-80 VM, Scheme 9, and the original P4 Pascal compiler. The compiler and interpreter implement the language specification; native backends and tooling are still work in progress, and the current native code generation prioritises simplicity over optimisation.

For more information see https://github.com/rochus-keller/Micron/blob/master/Readme.m....