5 open-source AI projects worth trying: FreeLLMAPI, OpenDots, T3 Code, Elephant Goldfish and FluidVoice

The short answer

These are five open-source projects that sit around the AI models you already use. FreeLLMAPI routes your app’s requests across the model providers you’ve connected. OpenDots, from CopilotKit, gives named agents a workspace you can come back to. T3 Code puts your Codex and Claude coding sessions, files and changes in one place. Google’s Elephant Goldfish has fresh-context reviewers check a written plan before you build it. FluidVoice is on-device dictation for the Mac.

The code is open source, but that doesn’t make every part free. Several of these still send work to paid or rate-limited model services, and each section below says which. If you already code with AI, try T3 Code, then Elephant Goldfish. For research and documents, start with OpenDots.

1. FreeLLMAPI: one router for your model providers

FreeLLMAPI gives your application one OpenAI-compatible address to send requests to. Behind it, the router sends them on to the providers you’ve added (Groq, for example) and, if one hits its free limit or fails, moves to the next model in your fallback chain. The router runs on your computer, but the models don’t: requests still go to each provider’s cloud, and you are still working inside each provider’s allowance. The project’s own README says it is for experimentation and learning, not production.

It also has launchers for coding clients. npx freellmapi launch opens Claude Code through the router, but the model answering is whichever one you configured, so it’s Claude Code’s interface, not free access to Claude’s models. In this video we explained the documented routing rather than running a new fallback test; our earlier FreeLLMAPI guide (https://lukejbyrne.com/library/guides/txy-dy0x1y4/) walks through the setup we used with Claude Code.

1. Install it: the macOS .dmg or Windows .exe from the project’s Releases page, or the Docker one-liner in the README (curl -fsSL https://freellmapi.co/install.sh | bash). Server installs need Node 20 or later or Docker.
2. Open the dashboard (http://localhost:3001 for a server install; the desktop app opens its own from the tray icon) and add your provider keys on the Keys page.
3. Reorder the Fallback Chain so the models you prefer are tried first.
4. Send a normal prompt in the Playground and check which provider and model answered it, and whether the answer is good enough for your job.
5. Then point your client at the router’s address (http://localhost:3001/v1 on a server install) with the unified key shown on the Keys page. Keep that key private.

2. OpenDots: an open-source agent workspace

OpenDots is CopilotKit’s open-source take on ChatGPT’s Dots: named agents (Dots) with their own instructions, access to the material they need, and Spaces where their documents live. Instead of pasting the same brief into a new chat each time, you keep the agent, the conversation and the document together. In our earlier OpenDots walkthrough (https://lukejbyrne.com/library/guides/dwalirqzh3o/) we connected a model, created a researcher Dot and gave it a task; it brought back a draft for review, the first draft needed a correction, and approve-and-save then put an editable page into the workspace.

It isn’t a fully offline app. Conversations need CopilotKit Intelligence (hosted, or a local Docker evaluation that still needs a CopilotKit sign-in and internet access), and the model provider receives the conversation. Our setup used a paid OpenAI API key; pages were stored locally. Per-Dot computers with browser and terminal tools come through CopilotKit’s OpenBot, which is another service to configure, so get one research Dot working in one Space first. The repository calls itself a template in early development, not a hosted product.

1. Install Node.js 24 and npm, then clone it: git clone https://github.com/CopilotKit/OpenDots.git and cd OpenDots
2. Install and configure: npm ci, then cp .env.example .env
3. Start it with npm run dev and open http://127.0.0.1:5173. You can create Spaces and pages before connecting anything.
4. Connect conversations: for hosted Intelligence run npx copilotkit@latest login and npx copilotkit@latest project select (it writes CPK_INTELLIGENCE_API_KEY to .env), or follow docs/SETUP.md for the local Docker evaluation. Don’t run copilotkit onboard in this folder.
5. Add OPENAI_API_KEY and OPENAI_MODEL to .env (your own key, kept off screen), restart npm run dev, then create one Dot with a clear role and one Space for its pages.

3. T3 Code: Codex and Claude sessions in one place

T3 Code is a control surface for the coding agents already on your machine. You open a project, choose a provider you’ve installed and signed into, and start a thread for the job. That provider still does the coding and still uses your own Codex or Claude subscription (we hit an account limit during testing); T3 keeps the conversation, files and changes together so you aren’t tracking them across terminal windows.

We tested version 0.1.7 by building a workshop run sheet: set a start time and sections, give each a duration, and the rest of the schedule moves when one runs long; it saves the plan and exports a CSV. Codex built the first version. Claude then got a copy in a fresh T3 thread with a precise request: a 90-minute workshop had stretched to 105 minutes, so fit it back to 90, keep the 10-minute welcome and 15-minute questions fixed, and shorten only the two 40-minute middle sections. The revised app split the 65 minutes into 33 and 32, showed a preview before applying it, and Undo brought the original timings back. We also tried T3’s worktree setup, so the agent worked in a separate checkout, and opened the interface in Safari on an iPhone on the same Wi-Fi to send a message.

1. Install and sign into at least one provider first, for example the Codex CLI (codex login) or Claude Code (claude auth login).
2. Try it once without installing: npx t3@latest. To install it, use the README’s install script (curl -fsSL https://t3.codes/install.sh | sh, then run t3) or the desktop app (brew install --cask t3-code on macOS).
3. Open your project, pick the provider, and start a thread for one job.
4. Ask for a change you can check: say which values may change and what the result should be, rather than “make the app better”.
5. Review the files and changes in T3 before you keep them; use a worktree if you want the original checkout left clean.

4. Google’s Elephant Goldfish: fresh plan reviewers

Elephant Goldfish (EGM) is an Apache-2.0 plugin in Google’s GitHub organisation; its README says it is not an officially supported Google product. The elephant is the agent with your project context that helps you work out the plan. The goldfish are reviewers that only get the written specification and the files they’re given, so they have to work from what’s actually written down and can catch missing requirements and awkward cases while you can still change the plan. Our Elephant Goldfish setup guide (https://lukejbyrne.com/library/guides/vm3_aieah8w/) covers the workflow in more detail.

We compared it with plain Claude using two fresh reviewers told to review, amend the plan and build: same model, same settings. Both websites passed the same 11 independent checks. Then we filtered the guide library to Tripo, clicked Copy link and immediately switched the filter to Codex, with the clipboard still running so it failed. The simpler version showed the old Tripo link under the Codex results; the EGM version detected the change and stopped it, a fix we traced back to one of the EGM review’s findings. That is one comparison, not a verdict on the method; the full comparison guide (https://lukejbyrne.com/library/guides/jtgauklu4ga/) has the briefs, reviews and results.

1. In Claude Code: claude plugin marketplace add google/elephant-goldfish-model, then claude plugin install egm@egm. In the Codex CLI: codex plugin marketplace add google/elephant-goldfish-model, then codex plugin add egm@egm.
2. Start a new session after installing. Brainstorming and review need a session that can create fresh subagents.
3. Explore the idea with /egm:egm-brainstorm, write the specification with /egm:egm-draft, then review it with /egm:egm-review design_draft.md (in Codex, pick the matching EGM skill instead).
4. Work through the findings and change the plan before you build.

5. FluidVoice: local dictation on a Mac

FluidVoice is a GPL-3.0 Mac app that turns your speech into text on your own computer and types it into other apps, so you can use it everywhere, including for writing longer instructions to your coding agents. Pick a speech model that supports the language you’ll speak: Parakeet TDT v2 and Parakeet Flash are English-only, Parakeet TDT v3 covers 25 languages, and Whisper covers up to 99. It needs macOS 15 or later; Apple Silicon runs every model, Intel Macs use the Whisper models. We haven’t run our own accuracy or speed test of FluidVoice, so try it on your own voice before relying on it.

Know what is local. The core app is open source and transcribes on your Mac. The optional Fluid Intelligence enhancement also runs locally (a model of about 3.5 GB), but that runtime is privately maintained, not open source. The optional AI Enhancement through OpenAI, Groq or a custom provider sends your text to that provider, so check which of these you’ve turned on if you want everything on your Mac. If voice models interest you, we compared eight local speech-to-text models on Luke’s Scottish accent (https://lukejbyrne.com/library/guides/qpsxna4gtfq/).

1. Install it with Homebrew (brew install --cask fluidvoice) or from the project’s GitHub Releases.
2. Grant microphone access and Accessibility access (needed to type into other apps).
3. In onboarding, choose and download a speech model for your language, then set your shortcut.
4. Dictate a sentence or a paragraph into a text field, including the names you say often, and watch the live preview.
5. Only then try longer dictation and any cleanup or enhancement. Luke’s first try at a ten-minute note with local voice AI didn’t work, so build up from short pieces.

Which one to try first

FreeLLMAPI puts several providers’ free tiers behind one connection. OpenDots gives you an agent workspace. T3 Code helps you manage coding agents, Elephant Goldfish reviews their plans, and FluidVoice lets you speak your instructions. If you’re already coding with AI, try T3 Code, then Elephant Goldfish. For research and documents, start with OpenDots.

Don’t build your whole workflow around one free provider staying available, and keep your API keys in .env files or the apps’ own key stores, never in a chat, a screenshot or a commit.

Links

FreeLLMAPI (MIT): https://github.com/tashfeenahmed/freellmapi. OpenDots (MIT): https://github.com/CopilotKit/OpenDots, with its setup notes at https://github.com/CopilotKit/OpenDots/blob/main/docs/SETUP.md. T3 Code (MIT): https://github.com/pingdotgg/t3code.

Elephant Goldfish (Apache-2.0): https://github.com/google/elephant-goldfish-model and https://egm.dev/. FluidVoice (GPL-3.0): https://github.com/altic-dev/FluidVoice. Follow each README for the version you install. This guide is free, with no email needed.

The takeaway

Pick the project that matches the job: FreeLLMAPI for trying models across providers, OpenDots for a persistent agent workspace, T3 Code for managing coding agents, Elephant Goldfish for reviewing plans before you build, and FluidVoice for dictating on your Mac. The code is open source, but check which model services each one still sends your work to.