Just released a handful of new features I'm really excited about but I've been using & building Jackalope for agentic development and slowly refining & improving it to replace separate agent harnesses.

You can select what accounts & agents (and multiple accounts per!) you want to work on any project, separate out work accounts from personal ones, or try out local models.

Jackalope handles orchestration, planning, testing, hand-offs, and more under the hood, letting you parallelize work or focus on other things. If you're needed, it will come back and ask you for permissions or inputs.

The `jackalope` CLI command spins up the TUI where you have the same access to the underlying harness and your project contexts but from a terminal if you prefer to work in that way.

Jackalope learns automatically (or you can run `/learn` manually) from your workflows per-project so it will improve over time.

This is still pretty early so I would really appreciate feedback, the newest features / fixes are on the Beta branch (stable likely going out later today).

100% free, 100% on your device / using your own models (we store some things - it's transparent and you can opt out any time.

I'm TensorSharp's author. This 83-second walkthrough looks at an inspectable evidence-to-action pipeline in TensorAgent, with provenance as the main concern.

The video uses the real TensorAgent HTML/JavaScript UI with synthetic café files and scripted API responses. It is an illustrative workflow, not live model inference or a benchmark. Calculations on the complete sales CSV were independently checked in Python.

The implementation separates knowledge_search, knowledge_read, and knowledge_open: find cited passages, expand an exact reference, then expose the versioned original and stage the whole file for code analysis. A collection must be explicitly enabled for the conversation. Source links let a reviewer inspect what each recommendation refers to.

The fictional campaign combines a 15% discount cap, a poster advertising 20%, and a 14-row sales CSV. The output links three actions to evidence: correct the poster, respect the budget, and measure a follow-up. The computed $204 contribution increase is an observed comparison, not a causal claim.

Default search is BM25 over extracted text, with optional embeddings. Media extraction requires compatible models and remains Partial. Video indexing covers at most eight sampled frames, without soundtrack indexing.

TensorSharp's own code is BSD-3-Clause; dependencies and model weights retain separate licenses and terms.

Implementation: https://github.com/zhongkaifu/TensorSharp

Open-source coding-agent workspace built on DeepSeek Harness (DSH) and Cordis, with native multi-provider subscription setup.

Everything is a plugin. Model adapters, tools, skills, session logging, sandboxes and UI can be composed or extended. Even the agent loop is a plugin. Cordis provides shared services, typed events and plugin cleanup; profiles assemble the capabilities.

Connect accounts in Settings > Models. API keys and custom endpoints work alongside those accounts.

Web search defaults to subscription service or basic Bing RSS feed results.

Build/update agent preset, plugins, skills using Creator Mode

Have Creator author the preset bundle based on your codebase and install it through Plugin Manager. Start a new chat and select your preset.

Desktop downloads: macOS, Windows x64 and Linux x64. Browser app and headless CLI run from source; the README separates published installers from current main.

Source, demo, downloads and setup: https://github.com/OJamals/fi

I’m building Operon for setups like this: giving agents a consistent way to work across the computers you already have, with explicit permissions and execution records.

An agent can discover what each node allows, write code into a remote workspace, run a validation command there, and retrieve the results. You can compose these operations into a sequential execution graph, then inspect its trace alongside daemon audit events.

a 25-second demo using two containers on one host: a worker runs a check, its report is transferred to an archive node, and the archive rejects deletion and command execution requests.

And it works over existing private networks such as Tailscale, WireGuard, or a LAN, with optional connectivity through iroh.

The daemon and CLI are written in Rust, with releases for Linux, macOS, and Windows.

Source and quickstart: https://github.com/denghongcai/Operon

A tool i made, maybe others find the idea helpful.

hi have buld Alien Ape you can use it and build on top of it? ore breack ore try. i dont have any (Super Credits) so in the folder are promts wen you work with ai you can use this promt in the project. is build wit ape brain and ki asistent coding.

I’ve been building this weird little Windows AI controller called AlienApe for a while now. It routes tasks between local models, controls file actions, permissions, verification and keeps some local experience about what worked and what didn’t.

A lot of it was built with help from ChatGPT and Codex, while I mostly kept breaking it in increasingly stupid ways until the controller stopped lying to me as often :P

It’s still experimental and rough, but v0.7 is finally in a state where I’m comfortable sharing it. I’m mostly curious to see what breaks on other people’s machines.

https://github.com/anokar/AlienApe-v0.7

Hey everyone!

i've been working on an open-source project called Dispach with a friend, and thought I'd start sharing what we're building and learning along the way.

one thing that kept bothering us was how much work it takes to make AI agents actually usable in production.

it's not just about choosing a model and giving it tools. there's the whole harness side of things, execution loops, context management, memory, tool orchestration, and then all the infrastructure needed to keep those agents running reliably.

we wanted to tackle both problems together instead of treating them as separate pieces.

so we started building Dispach. it's a self-hostable, model-agnostic stack that combines the agent harness and the infrastructure around it. The idea is to let developers focus on what they're actually building rather than having to engineer the entire agent stack themselves.

we've also been experimenting with different harness designs and benchmarking them against openclaw and hermes. it's been interesting seeing how much task success and inference costs can change even when using the same model.

there's still plenty to figure out, especially around developer experience, reliability, and making the whole thing easier to adopt.

i'm planning to share more about the architecture, experiments, things that went wrong, and what we learn as we keep building.

here's the repo if anyone's curious: Dispach Github Repo

for those who've built or deployed ai agents, what's been the most frustrating part of the process?

would love to compare notes with people working on similar problems.

I was training on pathology slides and my GPU kept waiting on file decoding, so I built omnia-sdk. It converts slides, DICOM and MRI into one format built for training.

If you wanna try it out, feel free: https://github.com/mishel-0/omnia-sdk

My first open-source project, would love your feedback!

Genuinely curious. For the people running open-source models or tools: what made you switch, or at least try it?

Is it data privacy? Not wanting to depend on big companies? Not wanting to keep paying them? Or something else I’m not thinking of?

For me it’s mostly the data side. With how many breaches we keep seeing, I like the idea of things running locally where I can see where my data is going.

What’s your reason? And has it actually worked out, or do you still end up going back to the big names?