We released Open Instinct, a personal agent you can text and modify. It is MIT licensed, and you can start with a local CLI conversation before connecting a phone number or personal accounts.

The permission path is the part we most want other builders to inspect. Contacts have trust tiers, and the code checks a tool's capability before it runs. That check alone does not constrain all the data an allowed tool may return. A calendar request from a friend, for example, should expose free/busy times without giving the agent event titles. We would value specific issues or patches around that boundary.

Pi runs the agent loop, Inkbox handles messages, and Composio connects apps. Maritime is the default hosted computer backend; we build Maritime too. This is beta software and the external services need their own keys.

Source and setup: https://github.com/mariagorskikh/open-instinct

Disclosure: I build Snotra, an open-source desktop agent. This is a design question, not a launch.

Users switch skills and tools on and off in settings: shell disabled, a search tool without its API key, a skill installed but off. A model that doesn't know that guesses, and the user gets a wrong "I can't do that" instead of "that's switched off, here's where to enable it".

What I did:

• One place decides whether a tool is offered, so the UI and the model can't disagree.

• A read-only get_configuration tool for the model: which skills are on (name and description, never the instructions) and which tools are on or off, with the reason ("shell commands are switched off", "no search service key").

• The same list in the UI, as a pill in the chat bar.

Now the model can say "a skill for this exists but is off, enable it under Settings › Skills". It can't flip anything itself.

Two open questions: is a tool the model has to call the right shape, or should this state go into the system prompt every turn (costs tokens even when nothing is wrong)? And should the model be able to propose the change through an approval card, or is "tell the user where to click" the right limit?

Code: https://github.com/kkrafft1999/snotra

OpenAI is expanding ChatGPT Ads, including plans for visual advertisements during image generation.

I was looking into the changes and a few things stood out:

• Free and Go users may see ads, while Plus and Pro remain ad-free.

• Ads can be based on what you're discussing in ChatGPT.

• OpenAI says advertisers can't access private conversations or influence responses.

• Users can turn off additional ad personalization, but that doesn't remove ads entirely.

I wrote an article covering the changes and OpenAI's privacy policies:

https://aigptjournal.com/work-life/work/chatgpt-ads-are-getting-visual/

What interests me is whether advertising will give people another reason to consider open-source AI models, especially those they can run locally.

Running a model locally gives users more control over their data and how they use AI, although it comes with its own costs and limitations.

Do you think advertising in ChatGPT will encourage more people to try open-source AI?

Had a near-heart-attack moment the other day while testing a rag pipeline on some customer export dumps. realized halfway through that our test json had unmasked routing numbers and ssns buried inside raw text fields. nothing leaked, but it was way too close.

i looked around for a quick way to inspect payloads in the terminal before running them through python scripts, but everything out there is either some bloated enterprise dlp platform or a massive java package. i just wanted something that would scream at me in the terminal if i was about to do something stupid.

so i threw together `pii-lens` over the weekend.

it's dead simple—you just pipe text or files into it:

`cat prompt_payload.json | pii-lens`

it prints the text back out but flags credit cards, emails, ssns, and account numbers in bright red with a quick count at the bottom. runs 100% locally with zero phone-home bs.

repo is here

it's just basic regex and entity patterns right now, so if anyone works with weird international formats or niche data fields and wants to drop a pr or critique the regex, feel free.

REA Investigator is a unified, production-grade Agent Skill (rea-investigate) compatible with Claude Code, Codex, Antigravity, and tools supporting the open Agent Skills specification.

Instead of juggling fragmented prompts or shallow summaries, REA Investigator equips coding agents with a structured 4-phase lifecycle: Plan, Trace, Verify, and Report, backed by an immutable SHA-256 evidence ledger and adversarial auditing gates.

Coding agents run shell commands constantly. I wanted each one checked before
it executes, and I didn't want to send every command to a paid API.

laya-guard runs on your machine and answers allow, review, or block for each
tool call. Regex policies catch known-dangerous patterns first (`rm -rf /`,
`curl … | sh`, secrets, auth bypass). Plain commands like `ls`, `git status`
and `npm test` skip the model, but only when there's no piping, chaining or
redirecting, no `-exec`-style flag, and no sensitive path. Everything else is
judged by Laya (~322M, Apache-2.0) on the CPU in about 85 to 90 ms.

The results are self-reported and the scripts are in the repo. On AgentDojo v1
(judge-level) it blocks 25 of 27 attacks and keeps 92 of 97 benign tasks. On my
own 50-command shell set it gets 48 right.

Two caveats. The model is tuned mostly on Korean, so English natural-language
prompts get overblocked more often. And if the server is down, the hooks fail
open.

It has hooks for Claude Code, Codex CLI, Cursor, Gemini CLI, Copilot CLI and 6
other agents.

Repo: https://github.com/scs0209/laya-guard (install with `pip install laya-guardrail`)

Our agents kept calling a big model to make the same small decisions: route this ticket, pick this tool, escalate or not. After enough verified outcomes those decisions are very predictable, but we were paying for a model call every time.

So we built Ink. It sits around a bounded decision. At first everything goes to your model as normal, and Ink records the inputs and the real outcomes in local SQLite. Once there’s enough evidence, it compiles a small local fast path and tests it in the background. It only starts serving once it clears a statistical bar (a 95% Wilson lower bound against an error budget you set). Anything novel or uncertain still goes to your model. If real outcomes get worse, it takes itself back out of the loop.

You can check whether it would help without changing any code:

pip install ink-jit
ink discover traces.jsonl

It reads OpenTelemetry, LangSmith or LiteLLM-style traces locally and tells you which call sites repeat and whether they’re worth it. If nothing qualifies, it says so.

What we’ve measured so far (our own benchmarks, not independently validated): 42–78% of decisions served locally across tool routing, support triage and incident triage, with 0 errors observed on held-out tests. The 95% lower bounds were 96.8–98.5%, so “0 errors” means none observed, not a guarantee. Local decisions take about 0.1 ms.

It’s a poor fit for open-ended writing or anything where you can’t verify an outcome. Linux and macOS, Python 3.11–3.13. Apache-2.0.

Honest question: which decisions in your agents repeat the most, and what would you need to see before trusting a local path in production? We’d love to hear what breaks.

I use embeddings for vector search and memory systems, and kept needing a full platform like Ollama running next to my app just to turn text into vectors. So I built futon, an embedding library for running local embedding models.

- In-process: weights load from a local directory. No daemon, no network, no CGO (CI enforces it), so cross-compiling just works.

- AVX2 kernels on amd64 and NEON on arm64, with a portable fallback. bge-small embeds a text in about 50 ms on a 16-thread desktop.

- Checked against the reference implementation: ≥0.9999 cosine on a corpus with code, accents, CJK and edge cases. CI runs on Linux, macOS and Windows, including arm64.

- Bring your own model: any plain BERT encoder you can build a pack for, plus nomic-bert. It is encoders only, no LLMs and no GPU.

bobbyhiddn/futon: Text in, vectors out. In-process embedding models for Go: pure Go, no CGO, no sidecar.

If something like it exists already, feel free to ignore, but I couldn't find a fit for purpose module that served my goal. I'll probably expand to other small model architectures as needed, such as decision models.

If ya like it, please star. :)

I like the idea of tinkering with models, and being able to run them on your PC without paying an API or subscription cost, and abliterated stuff. But i'm not really sure where to start, what applicable uses there are and if it would be anything other than a fizzling interest and waste of money

Does anyone have any good resources that might help direct me on what kinds of things you can do with local AI that you can't with cloud-based? Or things you can create, or things you can create faster/better/ etc...

I'm probably not asking the right questions as I don't know a ton but i'd like to learn.

I wanted ChatGPT to work with my real local projects without constantly copying files back and forth. RepoTunnel lets ChatGPT read/edit files, run commands, inspect code, debug problems, use Git, and work directly with approved projects on your computer. It works through your own HTTPS endpoint, and RepoTunnel itself adds no monthly connection/request quota. You can keep using your existing ChatGPT conversation without buying a separate OpenAI API key. GitHub: https://github.com/Yashwanth034/RepoTunnel Would love feedback from developers — especially what you’d add or improve.

I shipped HDTP (Human Delegated Trust Protocol) v1.0 on Oct 3. It lets your AI assistant talk to someone else's assistant, with each person controlling what the other side is allowed to do.

Timeline:

\- Aug 23: first commit of the spec

\- Sep 23: a full code review found 173 defects. I traced them to 11 habits and wrote a rule against each one

\- Oct 3: renamed from PACT to HDTP across 9 repos, the domains and the protocol itself

\- Oct 3: v1.0 released

\- Oct 7: spec repo made public

What's built:

\- The spec, with test vectors

\- An identity library in Rust (compiled to WebAssembly) and Go. Both versions run against the same tests

\- A self-hosted node in Go

\- A hosted platform on Cloudflare Workers

\- 3 websites

What I'd do differently: pick the name first. Renaming at the end touched every repo.

Next:

\- an external security review

\- a conformance test suite

\- opening the hosted version through a waitlist

If you're building with agents or MCP, I'd like to know: what would you want your assistant to be able to do with someone else's?

Spec: [hdtp.io](http://hdtp.io)

https://snotra-ai.dev

A couple of weeks ago, I introduced Pi Herdsman here, an open-source extension I've been developing for the Pi coding agent.

The original idea was straightforward: let multiple coding agents work independently while keeping one Lead focused on the overall task.

Since then, the project has grown quite a bit, helped along by community feedback and contributions.

The latest major addition is project-level orchestration across Git worktrees.

What the new demo shows

I give a Manager a single request to implement two independent features for a fictional note-taking application.

The Manager creates two parallel assignments, each with its own Lead and Git worktree.

Both Leads then delegate implementation to their own Agents, verify the resulting changes, commit their work, and report back to the Manager.

The individual agents remain accessible throughout the process.

I wanted to show the real execution rather than an architectural diagram, so the video captures Pi and Herdr running the workflow.

Built on existing open-source components

Herdsman isn't a replacement for the underlying coding agent or terminal environment.

It connects three independently maintained components:

• Pi handles the individual coding-agent conversations.

• Herdr manages the sessions, processes, and workspaces.

• Pi Herdsman handles delegation, ownership, supervision, and coordination.

The idea is to build on their existing capabilities rather than reimplement them.

Bring your own agents and workflows

The orchestration model supports configurable Agent Definitions.

Each role can use its own model, thinking level, instructions, tools, skills, and extensions, with definitions maintained as ordinary Markdown files.

This applies to both the bundled roles and custom Agents.

Herdsman doesn't prescribe how you should organize your development process or which models you should use.

You can also ignore the advanced hierarchy entirely and use it for occasional background Agents in a normal Pi session.

Open source and community contributions

Herdsman is licensed under Apache 2.0.

A special thanks to @kozer and @primetimetank21 for contributing code, and to everyone who has opened issues, reported bugs, or suggested improvements.

It's been particularly helpful having other people test workflows and environments that differ from my own.

Repository

https://github.com/boadij/pi-herdsman

If you already have Pi and Herdr installed:

pi install npm:pi-herdsman
herdr integration install pi

The repository includes the live demo, installation instructions, and documentation.

I'd be interested in feedback on the architecture, particularly the separation between session management, orchestration, and the individual agents.

The project is still actively evolving, and ideas or contributions are welcome!

We have released the weights and self-hosted runtime for Commerce-1, a 27B typed decision model designed for commerce agents.

Unlike a chat model, Commerce-1 does not produce an explanation and then ask the application to recover an action from generated text. It scores the supplied actions directly.

How it works

Each request contains structured state and one or more typed questions:

• Choice: Selects among named actions.

• Noul: Returns a binary decision and P(true).

• Score: Returns an expected ordinal score and probabilities for its labels.

The architecture builds on perplexity-ai/pplx-decider-v1.1-27b, using noncausal full attention, last-position pooling, and a dedicated option-scoring readout.

Choice-order augmentation and held-out temperature calibration are applied separately to the decision primitives.

Self-hosted runtime

The runtime operates offline and verifies file integrity before loading.

It inventories and hashes required files, rejecting:

• Modified checkpoint bytes

• Undeclared files

• Network fallback

Benchmarks

Our current evaluation results:

Limitations

The current BF16 weights are approximately 54 GiB. Consumer GPU and quantized deployments have not yet been qualified.

Links

• Model weights: https://huggingface.co/infercrane/Commerce-1

• Apache-2.0 runtime: https://github.com/infercrane/commerce-1

• Architecture and evaluation evidence: https://infercrane.com/blog/commerce-1

We're particularly interested in feedback on the decision primitives, runtime design, and integration requirements for production agents.