DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
Use a flat-priced, auto-routing LLM API in Aider or Cline — one npx command



Coding assistants like Aider, Cline, and Continue all speak the OpenAI wire protocol — point them at a base_url, give them an API key, done. That makes swapping in a different LLM backend trivial… if that backend uses Authorization: Bearer.

The flat-priced, auto-routing API I’d been using doesn’t. It’s distributed through RapidAPI, which authenticates with an X-RapidAPI-Key header instead of Bearer. So I couldn’t just drop it into Aider. The fix turned out to be ~120 lines, so I open-sourced it.

modelis-openai

A zero-dependency local proxy (MIT, Node 18+). It listens on 127.0.0.1, speaks plain OpenAI, rewrites the auth header, and forwards to the upstream gateway. Streaming (stream: true) is piped straight through, so token-by-token output works exactly as with the OpenAI API.

your tool ──OpenAI(Bearer)──▶ modelis-openai (localhost) ──X-RapidAPI-Key──▶ upstream ──▶ best model

Enter fullscreen mode

Exit fullscreen mode

Quickstart

npx modelis-openai

Enter fullscreen mode

Exit fullscreen mode

Then point any OpenAI-compatible tool at it:

Setting
Value

Base URL
http://127.0.0.1:8787/v1

API key
your RapidAPI key

Model
modelis-auto

Drop it into your tool

Aider

export OPENAI_API_BASE=http://127.0.0.1:8787/v1
export OPENAI_API_KEY=
aider –model openai/modelis-auto

Enter fullscreen mode

Exit fullscreen mode

Cline / Roo Code — API Provider OpenAI Compatible, Base URL http://127.0.0.1:8787/v1, Model ID modelis-auto.

Continue (~/.continue/config.yaml)

models:
– name: Modelis
provider: openai
model: modelis-auto
apiBase: http://127.0.0.1:8787/v1
apiKey:

Enter fullscreen mode

Exit fullscreen mode

Any OpenAI SDK

from openai import OpenAI
client = OpenAI(base_url=”http://127.0.0.1:8787/v1″, api_key=””)
print(client.chat.completions.create(
model=”modelis-auto”,
messages=({“role”: “user”, “content”: “Hello”}),
).choices(0).message.content)

Enter fullscreen mode

Exit fullscreen mode

How it works

Reads the key from Authorization: Bearer (or MODELIS_RAPIDAPI_KEY).
Rewrites the request model to modelis-auto (configurable).
Forwards to the RapidAPI gateway with X-RapidAPI-Key / X-RapidAPI-Host.
Relays the response — including SSE streams and rate-limit headers — unchanged.

It also answers GET /v1/models and GET /health so tools that probe on startup don’t choke.

Honest notes

It routes to a paid API (there’s a free tier to start). The point of the proxy is to remove the integration friction, not to give anything away.

Cursor isn’t supported — it sends requests from its own servers, so a localhost endpoint can’t be reached. This is for tools that call the API from your machine.

Links

If you try it in a tool I didn’t list, I’d love to hear how it goes.



Source link

AR4 Mark 5: This Open-Source 6-Axis Robot Arm Is Finally Done



A six-axis robot arm sitting on your desk used to mean five figures and a service contract. Chris Annin’s AR4 quietly tore that idea up — and with the brand-new Mark 5 revision, he’s calling the hardware officially finished.

The AR4 is an open-source, six-degrees-of-freedom robot arm you build yourself from CNC-cut aluminum, 3D-printed parts, and off-the-shelf motors and electronics. It’s the latest in a lineage that started with the AR2 and has been refined release after release. The Mark 5 isn’t a dramatic redesign so much as a final polish: Annin says it’s the last item on his hardware to-do list, with future effort going into software and tutorials instead.

What changed in the Mark 5

The headline tweak is sensing. Joints one, two, and three now use Hall effect sensors for their calibration limit switches instead of mechanical microswitches, which meant reworking a few mounting points on the aluminum parts. Joints four, five, and six keep the small microswitches. Annin has also shipped a fresh build manual and published the arm’s modified Denavit-Hartenberg parameters — the math that describes how each joint moves — as fully worked-out spreadsheets, so the kinematics aren’t a mystery you have to reverse-engineer.

Under the hood, the AR4 runs on a Teensy 4.1 with motors that have integrated encoders for closed-loop control, a setup carried over and tightened across earlier revisions. The control electronics live inside the base of the arm, and a larger base enclosure makes room for the terminal board and the gripper control board.

Build it yourself

This is a genuine DIY kit, not a toy. You’ll want a 3D printer for the printed components, the CNC metal parts and motors (kits and downloads are on the Annin Robotics site), and a Teensy 4.1 to act as the brain. The new build manual and DH parameter spreadsheets make it one of the more approachable paths into real industrial-style robotics — and there’s even a course aimed at schools, shaped by feedback from professors already using the AR4 in their classrooms. If you’ve got a Mark 4 already, there are upgrade instructions to bring it up to Mark 5 spec.

Originally published on blog.circuit.rocks.



Source link

Introducing Joanium: An Open-Source AI Desktop App That Can Actually Get Things Done



AI assistants today live in browser tabs. You open one for writing, another for code, a third because it’s better at research, and a fourth because your team uses it. Each one is locked to its own provider, its own pricing, and its own walled-off context. None of them can touch your files, run a command, or carry what they learned from one session into the next.

Joanium is built to change that.

Joanium is a local-first, open-source AI desktop app that runs on your machine, connects to nearly every major AI provider, and gives that AI the tools to actually act — not just respond.

Website: joanium.comSource code: github.com/Joanium/Joanium

One App, Every Model

Joanium supports Gemini, Claude, OpenAI models, and a growing list of additional providers including Fireworks, SambaNova, AI21, Lambda, and Hyperbolic — with live model fetching, so new releases show up without waiting on an update. You bring your own API keys and choose the right model for the task, the budget, or the moment, without rebuilding your workflow every time you switch.

An AI With Hands: 160+ Tool Integrations

Most AI tools can describe what they’d do. Joanium’s agents can go do it. With 160+ built-in tool integrations — covering platforms like GitHub, Gmail, YouTube, Linear, Netlify, Canva, and Stripe — Joanium can read your repos, draft and send emails, manage tickets, and interact with the services you already use, directly from a single interface.

Multiple Agents, Working Together

Rather than relying on one general-purpose assistant for everything, Joanium supports multi-agent execution along with a skills and personas system. You can configure agents for specific roles and let them collaborate on a task — closer to delegating work across a small team than managing a single chat window.

Full Visibility Into What Your AI Did

Two features sit at the core of how Joanium handles transparency:

Execution Replay — step through exactly what an agent did, in order, after the fact.Conversation forking with provenance tracking — branch a conversation in a new direction without losing the trail of where it came from.

When an AI is taking real actions on your behalf, being able to see — and audit — those actions isn’t a nice-to-have. It’s the baseline.

Built-In Browser, Git Integration, and a Marketplace

Joanium also includes an inbuilt browser for agents to use directly, native Git integration for working with repositories, a Daily Digest Agent that surfaces relevant updates automatically, and a Marketplace for discovering and installing additional tools and skills as the ecosystem grows.

Why Local-First, and Why Open Source

Most AI tools today route everything — your prompts, your files, your context — through someone else’s servers, under someone else’s terms. That tradeoff has been easy to ignore when AI was mostly a chat window. It gets harder to ignore once that AI is reading your emails, browsing on your behalf, and pushing to your repositories.

Joanium runs locally, and its source is fully open under the Apache 2.0 license. That means the code doing all of this is inspectable, forkable, and not contingent on a company’s roadmap or pricing decisions.

It’s also worth being precise about one thing: Joanium itself is free and open source, but using it still involves paying AI providers for API usage — there’s no way around that, and no product can honestly claim otherwise. What changes is who you pay and how much control you have over that. Instead of stacking multiple subscriptions regardless of use, you pay per request, choose your providers, and switch whenever it makes sense. For many people juggling several AI subscriptions today, that alone is a meaningful shift.

Get Started

Joanium is available now:

Website: joanium.comGitHub: github.com/Joanium/Joanium

Download it, connect an API key for a provider you already use, and explore what it can do. As an open-source project, feedback, issues, and contributions are welcome — and actively shape what gets built next.



Source link