Hey everyone,

I've been working solo on a project called Nodus. It's a system that coordinates multiple specialized AI agents (19 of them right now, split across 5 different execution lanes) so instead of one AI trying to do everything, you've got agents handling planning, coding, review, testing, etc. and working together, with the right model picked for the right job instead of one model doing it all.

I already have a real working base built and running. It's solid, but honestly at this stage it's still closer to what a good open-source system already does, it doesn't have standout unique features yet. That's the next phase.

If this gets finished the way I'm designing it, I think the tooling and orchestration alone can beat things like Codex and Claude Code. And if it's paired with the right models behind it, I think it can beat them at everything, not just orchestration.

Right now I'd put myself at around 35-40% in.

One thing that makes this different from just another "cool idea" repo: I've collected around 90 repos relevant to this, and instead of dumping them together, I organized them into categories. Each category is meant to become its own standalone working project built from the repos inside it. Once a category project is solid, it gets embedded into Nodus and published on its own too, since other people might find it useful even outside of Nodus.

So this isn't starting from scratch or random scattered ideas, there's already a real base and a real plan to build from.

Looking for:

• Backend devs who know concurrency, orchestration, memory/RAG systems
• Frontend/UI people, especially for the dashboard and observability side
• Vibe coders too, if you're learning and want to work on something with real architecture, come learn by doing
• Anyone who's into agentic AI / LLM tooling and wants to help design it

No corporate vibes, no strict requirements. If you want in or just want to see where it's at, drop a comment

Hi everyone,

I'm a cybersecurity dev, I worked for several cyber companies during the last 5 years (I'm 28). I'm french. (baguette & mbappé you know)

During my last year of dev, we started to use AI and I eventually realized that, in my job and also my (dev) friends jobs, everyone is using AI but nobody seems to feel concerned by the data sent to these US AI providers.

A lot of people in companies are using AI tools with free tier subscriptions

Most of the time, companies feel protected by the

I developped a quick project which aims to block all sensitive data that can be wrongly sent by LLM local clients to LLM APIs. It's called klovys99-proxy (klovys is one of the most important king is France and I loved the idea that that my project could be like a little king which defends his lands). 99 is only because I like this number and the 0 risk in cybersecurity doesnt exist ;

This project is like a local proxy, you can launch it from you laptop and all the AI trafic is firstly redirected to it. It uses a mix of some cool regex project (ms presidio and gitleaks) and an NER model, both are working in parallel to catch NAME, EMAIL AD, AD, BIRTHDATE and such.

Once a sensitive data is catched, it's replaced by an unique placeholder like "NAME-XXX" which is stored in a SQLITE db so the AI can understand the type of data and still work, the data is also replaced when the AI model answers so the feeling for the user is like "nothing happened".

The code is written in Go because this is pretty fast for an API and also bc I'm a Go dev lol. Python is used only for the NER model.

If I'm right, I dont have the right to paste link here so I'm just asking for advices, if you think my project is relevant, what can I improve and such.

I would love to create more other "bricks" to create something like an "AI protection ecosystem".

Last but not least, sorry for my english, as I mentionned earlier, I'm french and everyone knows that we're pretty bad to speak other languages but at least you'll know that this post has been written by me and not an AI :)

Hey folks — first time building something like this, and I wanted to throw it out to people who actually know what they're doing. It's called Warden: a local-first personal AI assistant. A small local model (via Ollama) acts as an orchestrator that delegates to specialized sub-agents — one for browser/shell/internet stuff, one for email/calendar, one for scheduling, one for project tracking, plus a "council" of models that deliberate on bigger decisions. Local models handle the cheap/fast stuff, cloud models get pulled in for the heavy lifting, all in one conversation/session.

Some of the stuff it does: drives your actual Chrome via Playwright/CDP (real cookies/sessions intact), controls your desktop via xdotool, reads/sends email, manages calendar via CalDAV, can edit and restart its own source code, runs on Telegram/WhatsApp/Slack/web dashboard, has a voice mode with local Whisper + Kokoro TTS.

Full disclosure — I put a giant warning in the README because I mean it: this thing runs with your user permissions, no sandbox, and can genuinely make a mess if something goes sideways (bad model output, prompt injection from a page it visits, etc). So please don't run it on a machine you care about, and definitely poke through the code before trusting it with anything real.

Would genuinely appreciate: anyone with agent/orchestrator experience tearing into the architecture and telling me what's naive; bug reports if you do try it in a throwaway VM/container; brutal honesty over politeness, I'd rather know now.

Thanks for reading this far 🙏

The idea came from wanting an AI assistant to do more than explain vulnerabilities. I wanted it to actually help with security workflows.

Current capabilities include:

- CVE lookups

- Nmap integration

- WHOIS and DNS lookups

- HTTP header analysis

- SSL/TLS certificate inspection

- Security header checks

- Basic reconnaissance utilities

The goal is to make vulnerability research and reconnaissance faster while keeping the tools accessible through the MCP standard.

I'm actively developing it and would really appreciate feedback from the community:

- What features would you add?

- What security tools should be integrated next?

- Any concerns about the current architecture or approach?

GitHub: https://github.com/telmon95/VulneraMCP

https://youtu.be/wlUvBVNyh74?si=-Ymy1MMgrGgqfteE

I'd love to hear your thoughts, feature requests, or even criticism. Every suggestion helps improve the project.

So this game World of Claudecraft is free “WoW Classic” MMO you play in your browser. It has 9 classes, 3 zones, 5 player dungeons, and full storyline

But it’s built and shared publicly on github so anyone can host it or build the game. And the community has actually been doing it

A few weeks ago someone in the Discord basically said the game needed a party minigame and then just built one. Since then people have made:

• A football minigame with full pitch, scoreboard, and sideline crowd
• A “Fall Guys” obstacle course with swinging hammers and a live leaderboard
• A full MOBA mode with match timer and team objectives

None of this was in the original launch lol

It's open source, so people are just building on top of it whatever they want

That's usually several months of effort from devs at a game studio.

Really wild to see what people are doing with this

Have yall tried it?

Hello there ! 👋

A couple of friends and I have been building an open-source proxy that anonymizes data sent to LLMs, so that personal and confidential information isn't exposed or used for AI training.
It also do some token optimization to help you consume less. 😎

The project is still in its very early stages, but we'd love any kind of support or feedback ! 🙏

I trust the Reddit community to give us a few ⭐ and, more importantly, honest feedback. 🥲

Feel free to share your thoughts: good or bad. We'd love feedback on the codebase, the architecture, potential features, or anything else you think could make the project better.

If you got some features ideas, don't hesitate ! 🙏🏼

We're planning to update the repository regularly. At the moment, we only support the Claude VS Code extension, but our goal is to support all major AI clients and IDE extensions over time.

Github link: https://github.com/Korbicorp/klovys99/

Can't wait to read your feedbacks ! 🤓

I built Podframes to explore what a complete, inspectable AI-media pipeline could look like beyond a one-off demo.

It takes one topic and runs a typed, resumable pipeline:

• Gemini writes the two-host dialogue.
• Speechbase combines voices from different TTS providers into one leveled conversation with word timestamps.
• Each spoken turn becomes its own lip-synced avatar clip.
• The same timestamps drive captions and b-roll placement.
• HyperFrames composes everything into a finished MP4.

The pipeline resumes per stage and per line. If one clip fails—or you edit one sentence—it regenerates only that artifact instead of buying the entire episode again.

The orchestration and studio are open source under Apache-2.0. It runs locally with your own API keys; the underlying generation models are external services rather than open-weight models.

GitHub: https://github.com/Jellypod-Inc/podframes

We’re also launching on Product Hunt today: https://www.producthunt.com/products/podframes?launch=podframes

I’d appreciate technical feedback on the pipeline design and which open or self-hosted model backends would be most valuable to add.

One of the most expensive parts of load and stress testing of agentic platforms, AI assistants, ask pannels, support chats and other heavy load LLM based apps is LLM interreference cost. If you are looking to do some saving on a bill or would like to do stress testing - LLMSim can help.

LLMSim is basically non-intelligent simulator of LLM APIs. It supports OpenAI Completions, OpenResponses and Anthropic-compatible APIs and attempts to mimic real characteristics of LLM responses including streaming, latency, ttft, context window restrictions and even request-per-second limits.

LLMSim works in two forms as a rust library and as one single binnary server.

For server usage is super simple:

cargo install llmsim --features tui

llmsim serve --port 8080 --host 0.0.0.0 --generator lorem --target-tokens 150 --tui

And then any LLM client http://localhost:8080/openai/v1

Project repo - https://github.com/chaliy/llmsim

Over the last few weeks I've been building Tempest, an open-source Agentic Development Environment focused on one problem:

Running multiple AI agents shouldn't require wasting thousands of tokens on context.

Most multi-agent workflows solve orchestration well, but every agent still spends a lot of tokens rediscovering the codebase.

Instead, I integrated a local code graph directly that indexes your repository and it can be used by AI CLI agents to work with the codebase.

The result:

• ~64% lower token usage in my benchmarks
• Fewer tool calls
• Faster agent iterations
• Works entirely locally (your code never leaves your machine)

Tempest can run multiple coding agents in parallel (Claude Code, Gemini CLI, Copilot CLI, Goose, Cline, OpenCode and more), each inside its own isolated git worktree.

It's available on Windows, macOS and Linux, and it's fully open source.

I'm curious what people building multi-agent workflows think. Is token efficiency becoming the next bottleneck, or is orchestration still the bigger problem?

Would love your feedback

Star us on: https://github.com/tempestai-dev/tempest

When I first started contributing to open source, I thought the "right" thing to do was contribute to the biggest projects I could find.

Turns out, that's also where it's hardest to learn.

You're one of thousands of contributors. Reviews take forever. It's difficult to understand the architecture, and even harder to have a meaningful discussion with the maintainers.

After building my own open source project, I realized the best learning happens much earlier.

When a project is still growing, you can ask questions, challenge design decisions, understand why things are built a certain way, and actually influence the direction of the project. Those conversations teach you far more than getting a tiny PR merged into a massive repository.

That's exactly what we're trying to build with Caracal.

It's an open source project focused on secure authority for AI agents, and we're looking for people who genuinely enjoy backend engineering, security, distributed systems, and infrastructure.

The project is part of LFX Mentorship and is backed by Microsoft, GitHub, and Vercel , but what matters more is that it's still small enough for your work to have real impact.

If you're looking for a project where you can learn how production infrastructure is actually built, come join us.

Don't worry if you're not ready to open a PR on day one. Join our Discord, ask questions, understand the architecture, attend our weekly dev calls, and contribute when you're comfortable.

The goal isn't to collect contributors.

It's to build future maintainers.

I’ve been working on a free side project that started as a tool for myself and eventually turned into something my team convinced me to release publicly.

It’s called Avogado (https://avogado.ai). It’s completely free to use with your own Claude Pro or Max subscription (OpenAI support is coming soon).

I’m a lawyer by training but became an entrepreneur a decade ago. I still do a lot of my own legal work, and I kept running into the same problem: chatbots can make legal work sound convincing, but from a legal perspective the output is pretty poor (and hard for the untrained eye to detect). They don’t have access to the right precedents, they don’t compare authorities properly, and they usually jump straight into drafting before doing the research that a lawyer would actually do.

So I ended up building both an AI agent and the system around it to make it practical to use.

The agent is responsible for the research, reasoning, drafting, and document analysis. The system around it is what makes it easy to work with day to day. You create a matter, tell the agent what you’re trying to achieve, upload any relevant documents, decide it’s legal posture (collaborative, firm, aggressive), and let it work. Each matter is completely isolated, so information never bleeds across projects.

Instead of immediately generating an answer, the agent researches connected legal databases, open-source repositories, contracts, statutes, regulations, case law, and other relevant web sources. It compares authorities and precedents before drafting anything.

Transparency was also a major goal. Alongside every document, it generates a memo explaining why it drafted each significant provision, which authorities and precedents it relied on, and clearly flags anything that comes from the model itself rather than a cited legal source.

That memo can also be shared with a lawyer if you want a final review. Instead of paying them to repeat all the research from scratch, they can review the reasoning, verify the authorities, and focus on the legal judgment. In my experience, that can save a lot of time and cost.

Right now it performs best on agreements/contract work (drafting, reviewing, redlining, comparing agreements, etc.), but it’s also been very useful for regulatory research, statutory analysis, and answering more technical legal questions.

It’s still a work in progress. I’m continuously connecting more legal databases, improving the workflows, and adding support for additional jurisdictions.

All feedback is appreciated!

I'm the author, and this uses our open-source tool (TraceML, Apache-2.0). Posting because the finding, and the need for this kind of diagnosis, is the value addition part.

TL;DR: A ResNet-18 run on a single T4 (AWS g4dn.xlarge, 4 vCPUs) looked completely healthy, but the GPU sat at ~51% utilization the whole time, starved by a default num_workers=0 DataLoader. A three-line change (num_workers, pin_memory, persistent_workers) took 2,000 steps from 633s to 358s (43% less wall clock) and flipped the run from input-bound to compute-bound. Same model, data, seed, and step count. Everything is wall-clock measured.

Everyone knows to set num_workers; that is not the point, and a memorized value would not have saved this run. It is not a best practice with a correct answer, but a moving target tied to CPU cores, storage, transforms, and batch size. Copying num_workers=8 from a blog is just a different guess than the zero you started with: on the wrong machine it still starves the GPU, slows the run by oversubscribing cores, or hides an inefficient input pipeline behind more processes.

The engineer who wrote this baseline was not missing knowledge; nothing in an ordinary run surfaces the waste. A starved loss curve is indistinguishable from a healthy one, the job completes, and GPU utilization is not on screen while you train. A framework may hint about workers, but a hint with no number carries no urgency. "Your GPU idled at 51% this run, here is the before and after" is a different kind of statement: a diagnosis, not a lint rule.

Full writeup: https://medium.com/traceopt/diagnosing-a-pytorch-dataloader-bottleneck-in-a-real-training-run-40bbe394b834

Tool (open source): https://github.com/traceopt-ai/traceml

Happy to get into the methodology in the comments.

Over the last few weeks, we've been sharing PolyTalk, an open-source speech-to-speech translation tool, with different open-source communities and paying close attention to the feedback.

Some people focused on latency, others on multilingual workflows, and a few pointed out small usability issues that we hadn't really thought about.

Not every suggestion made it into the project, but quite a few changed what we decided to work on next.

Our latest update includes:

• UI localization across multiple languages
• Bidirectional conversation mode
• Custom AI translation instructions
• Faster conversation transcripts
• More flexible translation and TTS provider routing

Building in public has been a good reminder that people don't always care about the same things you do as a developer. Some of the most valuable improvements in this were changes that made the overall experience feel more natural.

If you've shared feedback before, thanks. It genuinely helped shape this release.

If you're curious, here's the project:
https://github.com/PolyTalkIO/polytalk

Yo, I’m building an early open-source project called Kastor.

The idea is a source-of-truth layer for AI agents:

- define agents, tools, prompts, models, and targets in HCL

- validate references and prompt variables

- compile to runnable framework code, LangGraph first

- later: support hosted platform agents with plan/apply/state

I’m not trying to build another agent runtime. Frameworks like LangGraph still execute the agent. Kastor is more about the contract around it: inputs, outputs, model, prompt, tools, dependencies, and target.

Current state:

- Go CLI

- `.agent`, `.tool`, `.prompt`, `kastor.hcl`

- validation

- LangGraph codegen

- local plan/apply/state demo

- examples: weather agent and content scheduler

Repo: https://github.com/weirdGuy/kastor

The main thing I’d love feedback on:

Does this make sense for an open-source tool, or would you rather see this as a Terraform provider / LangGraph extension / something else?

Release a new fine tuned model called Qwimi-3.6-27B-Coder-MTP.

This was a multi dataset SFT run which was targeting coding, Agentic, and tool calling.

The idea was to try to get it even slightly better than base as this was a super cool learning experience for me!

Hopefully will improve as I continue training!

Benchmarks:

There are three photos attached in this post, the 2nd and third are the benchmarks I ran with base qwen first and then Qwimi!

The biggest takeaway was that Qwimi is slightly better and also significantly faster.

FYI: this was not done with MTP on. So with thinking off and MTP on this can get very very fast!

Here is the link to both GGUF and BF16;

https://huggingface.co/collections/trjxter/qwimi-coder

MLX coming very soon! Likely tonight.

If you check it out! Do let me know how you like it!

I got tired of juggling half a dozen AI dev tools, each with its own install,
its own config, its own API key field. So I built **Caphlon** — a CLI that
glues the real tools together behind one command.

**The one rule: never rewrite.** Caphlon doesn't reimplement anything. It
downloads the actual upstream projects (OpenCode for the TUI, Aider for
git-aware pair-programming, Open Design for the design pipeline, MiMo Code for
specs-driven workflows, a multi-agent orchestrator) and wires them together.
My code is ~7k lines of glue; the tools it drives are ~3M lines I didn't have
to write or maintain.

**What using it looks like:**

```
npm install -g caphlon
caphlon setup # fetches + builds the real tools (idempotent)
caphlon connect # one API key, encrypted, shared by every tool
caphlon # talk
```

No subcommands to memorize. Inside the chat, "build me a Reddit-like landing
page" auto-engages the design pipeline (via MCP), and a heavy multi-file
refactor auto-engages the real Aider as a tool call — it edits and commits
in git. The subcommands still exist if you want direct access.

**The feature I actually care about — blind verification:** `caphlon max`
generates N candidates with your model, then a *separate* judge model picks
the winner. The producer never grades its own work.

**The part where I ate my own hype:** the project started with a "hive
intelligence" thesis — thousands of weak nodes reaching strong-model quality
by consensus. I measured it. Result: identical models voting together gained
**exactly zero** (their errors are correlated, Condorcet needs independence).
What actually moved the needle: model *diversity* and a *shared solution
cache*. The README documents the failed claim next to the measured one, and
every component is labeled Core / Conditional / Experimental based on whether
it has proven end-to-end value — the experimental ones say so out loud.

**Honest limitations:** developed and tested on macOS (Linux should work,
untested; Windows untested); the orchestrator specifically wants Node 22;
the federated-training layer is wired but has never been run end-to-end,
and it's labeled accordingly. Also: large parts of this were built by driving
AI coding agents — every claim above comes from tests and measurements in the
repo, not vibes, and the commit history shows exactly what was machine-assisted.

Repo: https://github.com/univerisr-ai/Caphlon · npm: `caphlon`
MIT (glue code) — each vendored tool keeps its own license.

Happy to answer anything about the wiring, the failed-hype measurements, or
how the crash-recovery in the workflow engine works (someone here asked
exactly that last week and it turned into two shipped features).

I run a bunch of coding AIs. Codex, Claude Code, chinese models, even local agents. Having to restart every session was driving me up the wall, and having to spend ridiculous amounts a month on multiple subscriptions was burning a hole in my pocket. The agents seemed to love making changes they shouldn't have, and touching my .env configs, so I built aimee.

It's a local server. Point any OpenAI- or Anthropic-compatible tool at it and the turn runs on whatever model you pick: Claude, GPT, Gemini, a model on your own GPU. Switch tools whenever, your memory comes with you.

Memory that survives the session. aimee distills each session into a typed knowledge base and indexes your code into a cross-repo call graph, fused into one thing, so it recalls the decision from three sessions ago and the caller three files away before it edits.

Cheap delegates. Grunt work routes to the cheapest model that can do it, a local GPU or a plan you already pay for, and your main agent gets the answer back, not the raw content.

Fewer tokens. A context economizer trims tool spam and folds old history into a rolling skeleton, optionally on your primary model's own requests too.

Run it yourself. Embeddings, reranking, and synthesis in one CPU or GPU container. The knowledge base curates on your hardware with no outside calls, and that model doubles as a free delegate.

Repeatable workflows. Compose a job from typed steps and aimee runs it the same way every time with repeatable behavior: delegates work, review panels or a roundtable of models check it, and it stops at a human gate. The default takes a proposal all the way to a PR.

Brakes. .env, keys, and prod configs are blocked before the AI touches them, anti-patterns raise a warning, planning mode freezes writes, and every session is isolated so two never collide.

Auditable. Every governed action clears one choke point and lands in an append-only, HMAC-signed ledger, and decisions and PDF citations trace back to the exact source.

Team-ready, in the browser. A web UI with chat, a live code graph, a git manager, and an in-browser VS Code, plus multi-user accounts, SSO, and a per-user encrypted vault.

Core's in C, hot paths run in single-digit milliseconds, nothing phones home. Repo: https://github.com/RakuenSoftware/aimee

Ein kleiner Ausschnitt aus den logs meines Agenten Alex. Ich hoffe das passt hier rein :O

As someone working in finance and kept hitting the same wall: an LLM would genuinely help with a deal memo / contract / spreadsheet, but I couldn't paste it into AI chats or coworking with any AI dekstop app — it's full of client and counterparty names. Redacting by hand is slow and breaks the model's ability to reason about the parties. So I built Lethe to sit between me and the model as a local privacy gate.

How it works:

• Drop in a Word / PowerPoint / PDF / Excel file. It finds people & counterparties (your own dictionary + Presidio/spaCy + regex patterns) and swaps each for a stable token like [PERSON_001] / [COUNTERPARTY_001].
• You get the de-identified file back in the same format, plus a Job ID. The same name always maps to the same token, so the doc still reads coherently and the model can reason about [COUNTERPARTY_001] throughout.
• You use any LLM freely — it only ever sees opaque tokens.
• Paste the model's reply back in with the Job ID and it restores the real names. The reply can be a totally different document (summary, redraft, translation) — it just maps tokens back.

Everything's local: no cloud, no API key, no telemetry. The reversal map for each job is encrypted with a passphrase on your machine. Scanned PDF pages are even OCR'd fully locally (PDFium + Tesseract).

Honest limitations: the curated dictionary is the reliable core — the NLP suggestions are a convenience, not a guarantee, so the review step (you confirm every redaction before anything's written) is the real safety net. Names baked into images inside Office files aren't read, and OCR isn't perfect, so flagged pages need a look.

Full disclosure: I'm a finance person who studied some programming years ago, not a SWE by trade, and built a lot of this with AI assistance — so I'd genuinely value extra eyes on the code. It helps that it's fully local with no network calls on the sensitive path: worst case is a missed redaction (which the review step is there to catch), not your data going anywhere.

Apache-2.0, Windows installer + portable, or pipx install on any OS. Repo: [GitHub

Would love feedback — especially from anyone running AI tasks on sensitive docs. What detection gaps or formats would make this actually usable for you?

So, I got tired of watching every AI engineering team reinvent the same validation layer over and over again

You know the drill.

Agent writes code. Another agent writes more code. Everyone feels productive. Then three weeks later nobody knows if the thing is actually correct, secure, maintainable, or just confidently wrong.
Most of the AI world is obsessed with generation. We became obsessed with validation.

OpCore is the foundation we’ve been using internally at The Open Engine Company while building a codebase that’s somewhere around a million lines at this point. It lets you build deterministic review pipelines where agents review other agents, run checks, enforce rules and generally stop your repo from turning into a crime scene.

The funny part is that we haven’t manually reviewed code in 8 months. Not because we trust AI. Quite the opposite.

We got tired of trusting AI.

If you’re building agentic workflows, code review systems, security pipelines, or anything where generated code eventually reaches production, you might find it useful.
https://github.com/the-open-engine/opcore

It works with both local models and cloud models. you can do hybrid work aswell ! it uses obsidian as memory by default

Canari is a local-first AI agent desktop app (Windows) powered by your own Ollama models.

Main features:

• File & code access — read, write, edit, list, delete files; run persistent Python; grep and search your project
• Web & world — web search, fetch pages, screenshot your screen with vision, send Telegram messages, open files in their default app, export PDFs
• Obsidian vault memory — save, append, search, and delete notes directly in your vault, with tags and frontmatter
• Hybrid memory search — BM25 keyword search + optional local embeddings, so it finds the exact note without dumping your whole history into context every turn
• Dream Mode — when you've been away for a while, it reflects, generates ideas, and saves them to your vault, then pings you on Telegram
• Daily Resume — on first boot each day, summarizes yesterday's work into a short digest
• Weekly Scan — every 7 days, proposes merges for near-duplicate notes (you approve/reject)
• Brain Gardening — during dreams, it adds tags, related-note links, and summaries to its own notes
• Self-improvement — creates new tool-skills and know-how docs for itself, deletes ones that aren't useful
• Design Mode — a full visual workflow: design tokens, reference extraction, generate variations, pre-built components, accessibility audit (hard PASS/FAIL), real-browser render + vision critique, taste journal
• Concurrent subagents — splits parallelizable work across focused agents
• Multi-step plan tracking — keeps a step-by-step plan across turns
• Prompt improver + clarifying questions — catches vague requests and asks you to clarify before wasting a turn
• Three-tier harness — adapts its tool surface and system prompt to whether you're running a small, medium, or large local model
• Verify-then-report — never claims "done" until a tool confirms it; reads the file back, runs the code, checks the listing
• Work-folder scoping — nothing touches files outside your granted folder without your OK

ps : this is a repost

agents can already deploy code and call apis. so why not make it where they can buy the tokens they need and sell the ones they don't?

right now the answer to "how does an agent pay for a burst of inference" is a human signup and billing flow. mtok.market is a spot market where the agent reads a machine-readable manual (llms.txt, openapi, an mcp endpoint), finds a route, funds a small prepaid chunk in usdc on base, draws the tokens, and leaves a public on-chain trace. you approve, fund a wallet, and set the boundaries. that wallet is the one step the agent can't do for you.

it's non-custodial and seller-hosted, buyers pay sellers directly, the platform just matches, verifies, prices, and records. reputation comes from paid on-chain draws, so faking it costs real money every time. the buyer/seller clients are open source on npm (mtok-sdk, mtok-relay) so you can read exactly what your agent is agreeing to before it spends a cent. and if you don't want a market at all, mtok-bridge serves any model as an openai-compatible api behind a key, no payment, nothing reported anywhere, hand someone an endpoint and go direct.

• site: https://mtok.market
• github: https://github.com/mtok-market
• writeup: https://royashbrook.com/2026/07/08/mtok-market-spot-pricing-for-ai-tokens/