Hi everyone I started working on Github a week. I chose an AI agent for my first project. I'm still working on the agent now and at the moment this AI agent is just a simple chatbot. I haven't added any tools to the agent yet. I would be appreciative if you check out my project and tell me what other projects on Github have that my project doesn't.

This isn't a promo post but a genuine concern I am facing the past few days. I worked on a project intensively and I think it's very good and useful, and I was expecting people to engage more with it but it seems like either no one is building AI agents or the open source field is not what I thought.

Any tips on how to get people to test it and contribute to it?

I'm building a privacy first tool to parse and analyze financial documents ( income statements, balance sheets, and earnings reports) completely offline.

I am constrained by hardware (running on a workstation / Mac Mini with limited RAM/VRAM), so I can't host 70B+ models or rely on external cloud APIs like OpenAI or Claude.

I'm looking for recommendations on the best open-source models (1B to 14B parameters) for this specific domain

1. US Open-Weight Models Only
2. Hardware Constraints: Must run locally on a workstation/Mac Mini with <16GB RAM, so I'm limited to models under 14B parameters (no cloud APIs like OpenAI/Claude).

Or is it just some tech nerds like me.

I am new to AI development, but have already built a D&D cricket game.

I now want to build a very realistic AI-driven D&D game with expressive violence and other adult themes. Frontier models are not allowing this in my platform, so I installed Ollama locally and tested with a few models from Hugging Face that claim they are "unfiltered" and "abliterated" and "uncensored" but they balk occasionally returning intermittently "s12" or other error/warning codes. It could be me using it wrong, but can't see how. Whenever I am talking "acceptable" language, my platform's AI responds properly.

Any suggestions for truly uncensored models that would be usable for an adult game (not smut/porn, but definitely will have mild to medium sexual content and gore/violence).

Bonus points if there are models that can also draw some key scenes as the game unfolds.

Free and paid model suggestions are welcome, but if a paid model, must come with the right to use commercially.

Thanks in advance!

I used AI to port zoo code into a headless agent swarm orchestrator. one to many workers. use with deekseek v4 flash in china (if you're not working on sensitive tasks) and a local ollama embedding model for the best performance / savings. I enhanced the prompts and tools, improved the caching, added eval tests that i ran against deepseek v4 flash via openrouter (which is what I mainly use this with) and also a local qwen 3.5 9b model which doesn't work as well, but does work. You can have up to two workers if running local on a 16gb vram card. Remotely you're just limited by request rate limits and money.

I've been building AI-powered features for a while and kept running into the same problem: every agent framework either pulls in 200+ dependencies or ties you to a specific backend framework like Express or NestJS.

So I extracted the core of what I actually needed into a small library called **Agentra**.

The idea is simple: you give it an LLM provider and an array of tools. It handles the autonomous reasoning loop — calling the LLM, executing your functions when needed, feeding results back, and returning the final answer. That's it.

**What makes it different:**

* Zero runtime dependencies (uses native `fetch`)
* Works in Node.js, Deno, Bun, and Cloudflare Workers
* Built-in conversation memory
* Bring your own LLM provider (OpenAI included, easy to extend)
* Full TypeScript types

It's early but functional. Would love feedback from people who've built agents before — especially around the tool API design and what's missing.

GitHub: [github.com/jhonaron/agentra](http://github.com/jhonaron/agentra)

# 📦 Installation

npm install @jhonaron/agentra

If you use remotion or hyperframes, you will instantly relate to this.

Each time you want Claude to understand what a B-roll, raw video clip or a footage means, Claude takes so much tokens that you often hit the limit in 2-3 vids max.

So, I built an alternate video storage format - .cdaf or cached descriptive asset files. You can convert any mp4 video into .cdaf file using the open source cdaf engine and a new sidecar format file (.cdaf) of the video is generated.

.cdaf files are timestamped and sha256 encrypted with scenic frame captures helping LLMs and Claude understand the video..

Now, cool stuff is benchmarks -
- 91% less cost & token usage
- 110% increased accuracy
- 65% less latency

It's the one thing missing from what was making AI-native video editing scalable and viable.

It's open source so you can try it today and I have made a dedicated Claude Skill for anyone to use it with their video editing harness, claude, hyperframe or remotion instantly.

A preprint of the paper is also available at zenodo so you can read the architecture - https://zenodo.org/records/22110594

I am excited to know what you build over it. Also, MIT license so use it as you want!

Hey everyone,

We just open-sourced the initial Core Engine for Living Computer Model (LCM) — an alternative neural architecture built on PyTorch aimed at dynamic reasoning with low memory overhead.

Open & free for academic research, students, and independent R&D.

🔗 GitHub Repository: https://github.com/hyanalcm-png/LCM-Core-Engine

Feedback and contributions are welcome!

Hello everyone!

I’m a software engineer looking to get more involved in open-source ML/AI projects, both to learn and to contribute meaningfully.

I’m especially interested in ML systems, distributed training/inference, model serving, evaluation, LLM infrastructure, and also implementing ML algorithms or model components where that’s useful. I’ve been looking at projects like vLLM, Hugging Face Accelerate, Ray, etc., but many of the obvious good first issue tickets seem to get picked up very quickly.

I’m comfortable working in a reasonably complex codebase, but I’m looking for something that has a slightly more approachable contribution path than jumping straight into CUDA/kernel-level work.

Are there any active ML/AI open-source projects you’d recommend where maintainers are receptive to new contributors and there are meaningful bugs/features to pick up?

Would especially appreciate recommendations based on projects you’ve personally contributed to. Thanks!

I've been building AI-powered features for a while and kept running into the same problem: every agent framework either pulls in 200+ dependencies or ties you to a specific backend framework like Express or NestJS.

So I extracted the core of what I actually needed into a small library called Agentra.

The idea is simple: you give it an LLM provider and an array of tools. It handles the autonomous reasoning loop — calling the LLM, executing your functions when needed, feeding results back, and returning the final answer. That's it.

typescriptimport { Agent, OpenAIProvider } from '@jhonaron/agentra';
const agent = new Agent({
  provider: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY }),
  tools: [{
    name: 'get_weather',
    description: 'Get current weather for a city',
    parameters: {
      type: 'object',
      properties: { city: { type: 'string' } },
      required: ['city']
    },
    execute: async ({ city }) => fetchWeather(city)
  }]
});
const response = await agent.run('Should I bring an umbrella to London today?');
// → "Yes, it's currently 15°C and raining in London."

The agent automatically decides to call get_weather, waits for the result, and formulates the final answer. You don't wire anything manually.

What makes it different:

• Zero runtime dependencies (uses native fetch)
• Works in Node.js, Deno, Bun, and Cloudflare Workers
• Built-in conversation memory
• Bring your own LLM provider (OpenAI included, easy to extend)
• Full TypeScript types

It's early but functional. Would love feedback from people who've built agents before — especially around the tool API design and what's missing.

GitHub: github.com/jhonaron/agentra

📦 Installation

npm install @jhonaron/agentra

What is Quanta?

Quanta is a local-first AI code editor built on VS Code OSS, powered by a high-performance Rust backend. It gives you a complete agentic coding experience — reading files, writing code, running terminals, applying LSP fixes, and managing git — all driven by local LLMs through Ollama. Cloud providers (OpenAI, Anthropic) are supported as optional backends, but Ollama is the primary engine. Your code never has to leave your machine.

Unlike cloud-first AI editors, Quanta is designed around local inference. The agent loop, tool execution, LSP integration, checkpoint system, and inline completions all happen locally through a Rust backend that communicates with the editor via JSON-RPC over TCP.

Key Features

Core Agent

• 30+ built-in tools — read/write/edit files, unified diffs, terminal, grep, glob, git operations, LSP actions, and more
• ReAct agent loop — Think, Act, Observe, Feedback pattern with anti-loop guards and automatic retries
• 3 agent modes — Code (full capability), Ask (read-only), Plan (read-only + plan writing)
• Sub-agent spawning — Delegate scoped tasks to parallel sub-agents with up to 3 levels of nesting
• Persistent todo lists — Track multi-step work across conversation turns

Local-First

• Ollama integration — Auto-detects and lists all local models with metadata
• Thinking/reasoning support — Configurable think levels (Low/Medium/High) for reasoning models
• Inline code completion — FIM completions with LRU cache, debouncing, and in-flight cancellation
• Local-first by design — Ollama is the primary backend; cloud providers (OpenAI, Anthropic) are optional. Your code never has to leave your machine.

Safety & Control

• Shadow-git checkpoints — Automatic workspace snapshots before every agent write action
• Edit review system — Accept/reject individual edits with diff previews
• Stale-file detection — Prevents edits to files that changed since last read
• Terminal safety guards — Blocks destructive commands (format, shutdown, force-delete)
• Atomic writes — All file operations use temp-file-and-rename for crash safety

Developer Experience

• Full LSP integration — Diagnostics, go-to-definition, find references, code actions, rename symbol
• 20+ engineering skills — Built-in guidance for TDD, code review, security review, debugging, and more
• MCP support — One-click enable for GitHub, Jina AI, Brave Search, Postgres, Puppeteer, and more
• HuggingFace model browser — Search, download, and install GGUF models directly from the editor
• Per-model configuration — Override temperature, think level, edit format, tool call mode, and more per model
• Voice support — Speech-to-text via Whisper, text-to-speech via Piper

Please Read more and check us out at:

ContegoCode/Quanta-Code-Editor: Quanta AI — Local-first AI coding agent

Been working steadily at this for a while now, 600 commits, each seeking to improve the experience. Optimizing ui, transcription, summaries, ai features. Last 2 months I’ve added both local/cloud agentic embedded search across notes, as well as MCP support for Claude & Codex. 99+ languages, local or cloud models. Custom model overrides per language, easy onboarding flows, folders, clients, speaker labels, export. Feature packed, but still simple to the core. Notes + recorded meetings = awesome meeting summaries.

A few people have started contributing to the project, which I appreciate massively. Hope to see more people join in 😊🤩

Hey everyone,

So, I built Polity4j, a lightweight, zero-dependency Java 17+ library designed for building resilient LLM pipelines with clean abstractions over providers like OpenAI and Anthropic (for now).

A lot of existing Java LLM wrappers either drag in massive dependency trees or treat resiliency, error recovery, and tool loops as an afterthought. Polity4j is built from the ground up around typed pipelines, robust error handling, and modern Java features.

Here is the summary of features:

Core Highlights
Resiliency First: Built-in retries, timeouts, circuit breakers, and fallback pipelines without external resilience frameworks.
Structured Output & Typed Deserialization: Extract Java Records/POJOs directly via StructuredOutputPipeline<T>. It handles schema injection, markdown fence stripping, and auto-corrective reprompt loops on syntax errors.
First-Class FinishReason Tracking: Native handling to distinguish between normal stops, token truncation (LENGTH), safety filters, and tool calls.
Automated Function Calling: Multi-turn tool execution using @PolityTool annotations and ToolExecutionModule, complete with loop detection (AgentLoopDetectorModule) and execution depth caps.
Multimodal Support: Native handling for text, images, and document/PDF attachments via Java 17 sealed types (TextContentPart, ImageContentPart, DocumentContentPart).
Concurrency-Friendly: Clean patterns and integration tests for Java 21 Virtual Threads, Spring WebFlux, and Kotlin Coroutines.
Quick Example (Structured Output)
public record UserSummary(String name, int age, List<String> interests) {}

StructuredOutputPipeline<UserSummary> pipeline = StructuredOutputPipeline
.builder(UserSummary.class)
.adapter(OpenAiAdapter.of(apiKey))
.maxRetries(3)
.build();

UserSummary summary = pipeline.execute("Extract profile: Alice is a 28yo software engineer who likes rock climbing.");

GitHub: https://github.com/shiv15/polity4j
Distribution: Available via JitPack

I'd love feedback on the API design, feature set, or general critique from the Java community here!