andes314

To whoever messaged “what is Manchester United” and got an airline ad, come on, that’s pretty cool right? I’d really love some discussion on this as I have not yet seen ads in GenAI apps and wanted to experience them.

skills.md:

# ClawJetty Skills

ClawJetty lets you create a live public progress page for a task.

## Goal

Before starting work, create a run and return its public URL to the user. As you work, post short progress updates. When finished, post a final event marking the run complete or failed.

## Base URL

https://clawjetty.com

## API

### 1) Create a run

POST /api/runs

Request body:

```json { "title": "Researching CRM tools" } ```

Response body:

```json { "id": "run_abc123", "viewer_url": "https://clawjetty.com/t/run_abc123", "status": "active" } ```

Create the run before doing the task. Return viewer_url to the user immediately.

### 2) Post an event

POST /api/runs/{id}/events

Request body:

```json { "kind": "update", "message": "Comparing 5 tools by price and features" } ```

Allowed event kinds:

- update - complete - fail

Example complete event:

```json { "kind": "complete", "message": "Finished. Sent final recommendation to user." } ```

Example fail event:

```json { "kind": "fail", "message": "Failed due to missing access to the source system." } ```

## Usage rules

- Create the run before starting the task. - Return the viewer_url to the user immediately. - Post short updates after meaningful steps. - Keep updates short and plain. - Do not flood the run with tiny updates. - Do not include secrets, passwords, API keys, or raw private data. - End every run with either complete or fail.

## Good update examples

- Reading the uploaded PDF - Summarizing the findings - Drafting the email reply - Blocked waiting on missing invoice number

## Bad update examples

- Thinking - Working - Doing stuff - Long dumps of raw content

A quick tool to give your AI agent a live status page. I made this after being frustrated with the lack of visibility in tools like OpenClaw. Open to feedback.

Good call, worth adding!

I’m building ClawJetty: a small, always-on mini PC that runs a personal OpenClaw instance with minimal setup (pair from an app, connect your chat channel, done). The point is to make “self-host your agent” feel like setting up a router, not a weekend project.

Pricing is two tiers and two purchase options:

Plus: $149/mo with a 12-month commitment (box included) or $449 upfront + $119/mo

Pro: $269/mo with a 12-month commitment (box included) or $449 upfront + $219/mo

Plans include managed updates + rollback, safe defaults (no exposed inbound ports), and address collection at checkout for fulfillment. AI usage is bundled with included allowance; overages/top-ups will come later.

Looking for feedback from people who’ve self-hosted agents (or tried): what parts of setup/ops were the biggest pain, and what would you demand from an “agent appliance” to trust it?

Linear time attention doesn’t work, by principle. Dead end pursuit. Much great research on more efficient quadratic time inference

SEEKING WORK, Boston, MA (open to relocation), Remote Welcome.

https://rlafuente.com

ML Engineer with experience in high visibility DARPA and DAF projects. I charge $200/hour for time spent in an interview process.

Putting my profile on here for anyone who is looking for an ML Engineer. I have worked on AI/ML development on highly visible DARPA and DAF programs. I generally charge $200/hour for time spent interviewing.

This platform is an mcp client and mcp server creator tool. You make the mcp servers from APIs. It is a “Postman” tool in two ways

Less than you’d think

It is a platform to create MCP servers from API endpoints, and then chat with them without having to use Claude’s clunky integration process. It is simple and complete.

My platform goes beyond being an automatic wrapper of an API and lets you specify to the model, in natural language, how it should parse inputs and outputs. I find LLMs are very responsive to this type of specification, and to the best of my knowledge no one is trying this yet.

You also don’t seem to offer a simple chat-based client.

If it enters hug of death, please try Claude client to test it! Anthropic allows me only 30req/s at the moment

For anyone confused, you can play with mcp for free on usetexture.com

This is what the no-code API-to-MCP creator uses at usetexture.com! I was surprised to find out this is not what the Claude client uses (as of May 2025)

How about acting? Can your platform have a chat window create a ticket or send a message? I feel there is so much search already.

I am releasing this tool, if you have feedback please include it below. I will be writing a write-up about this tool if it gets enough usage. This tool creates MCP Servers from APIs in a no-code fashion, and hosts them for you. Kinda like a wix.com for MCP servers, but also meant a little more for more people who know what APIs are. Above all, it is a tool to get started playing around more with MCP servers.

Found a tool that actually allows you to use MCP servers easily. Go Cloudflare.

[Excerpt from Article]

This is a small project that packages a Flask app in Docker and deploys it using Docker Compose. It runs a server that returns `"crouton!"`, the current time, and a visitor count that persists across restarts.

* The codebase: https://github.com/rodlaf/crouton * You can try it here: https://crouton.rlafuente.com * The idea was originally inspired by https://crouton.net

The app itself is trivial. But what you get, by building and deploying it properly, is a full walkthrough of how web services actually make their way from a script on your laptop to something versioned, persistent, and runnable everywhere.

It touches on containerization, orchestration, logging, port forwarding, file persistence, and shipping artifacts to Docker Hub. All in about 30 lines of Python.

Radix sort??

That's awesome! Yes, not being able to place fractional cent costs makes the problem unique relative to other markets.

I will give this a shot! And if you would be willing to collaborate, please shoot me an email.

This is a great question! Yes, for a very specific subset of problems--those where you need total recall. HNSW-based algorithms typically only compare against a subset of the whole collection in order to achieve much faster results than linear time search, and it is sometimes the case that they miss the true best results, which is a trade-off worth making. I aimed to keep total recall and my method does in fact perform faster for this particular use case.

The radix selection algorithm is a modified radix sort that, since we don't care to sort the whole list but rather just the top K results, manages to cut some of the time out of the algorihm. It was an awesome way to get experience in CUDA programming.

Radix sort works with any ordered sets--it just lends itself well for GPUs since it is designed to be run in parallel. I used the modified version to get the best hamming distance results quickly, and implemented a few other distance measures as well (e.g., cosine distance)

You treat a single side (yes or no) as a contract and do it as you would any other security. The difference here is you can hold “negative” stock which is stock in the opposite side. To reduce inventory risk you adjust your willingness to sell/buy so you’re always hovering around zero.

Not as big as other markets, but growing fast!

I gave it some cash but in the end, with my risk configuration, it wasn't 'exciting' enough because orders don't really get taken very frequently. I think You'd have to deploy much more cash than I did (> $1000) and trade at least a couple dozen securities to really make it 'fun'.

A major improvement to the software that I didn't get around to was a script to identify which securities offer the best market making opportunities (e.g., maybe by generating a custom YAML file).

This was an experiment to both 1) learn how market making works and 2) figure out what is so hard about it. My main insight from this process is that order management--making sure only the orders you want are placed, and fast, is a pretty complex software problem. The algorithm itself seems to be one of the easier things to implement.

High-performance computing (HPC) remains a critical enabler of modern AI research, yet the divergence between cloud-based and on-premises infrastructure has created a challenge for researchers and engineers. On one hand, cloud computing offers scalability and convenience, but at a significantly higher cost. On the other hand, on-premises clusters, often managed with Slurm, provide cost efficiency and control but lack seamless compatibility with modern AI-centric cloud tools like Ray. This is where Syndeo comes in.

Syndeo is an open-source software framework that allows developers to run Ray clusters on Slurm and other HPC environments with secure containerization. The goal is simple: write code once, deploy anywhere. By bridging the gap between cloud and on-premises compute, Syndeo enables researchers to leverage the best of both worlds.

I built a market making algorithm for Kalshi, an event futures exchange. The algorithm dynamically places bids and asks to capture the spread while managing inventory risk. It supports multiple strategies running in parallel, each with its own configuration. The codebase is located at https://github.com/rodlaf/kalshimarketmaker.

A better alternative, which uses a .gitignore-like file to ignore specific files: https://github.com/rodlaf/describe