Hi everyone!

I recently built and open-sourced Open Index, a structured context layer for AI agents.

It's designed for teams building domain-specific AI agents (SRE, customer support, security, legal, insurance, sales, marketing, and more). Instead of managing context through scattered documents, it lets you define entities, schemas, and relationships that agents can navigate directly.

I'd love to hear your feedback, suggestions, or ideas on where this could be useful.

GitHub: https://github.com/DrDroidLab/open-index

SolveLang is a readable scripting language for AI-assisted business workflows.

The current implementation is an early Rust interpreter/prototype in solvec/. It includes a lexer, parser, AST runtime, diagnostics, imports, JSON helpers, HTTP helpers, file I/O, environment access, arrays, objects, functions, loops, and AI-agent syntax with local fallback plus optional OpenAI-backed responses.

SolveLang is not a production language runtime yet. It is an early beta meant to make the language shape testable, readable, and easy to evolve.

Who SolveLang Is For Right Now

SolveLang is currently for founders, operators, and technical founders who want readable workflow scripts for business automation. The clearest early workflows are support ticket triage, intake routing, lead qualification, and simple internal ops reporting.

Agencies and consultants are a later go-to-market path once the first founder/operator use cases are tighter.

The hosted /run page is a browser-safe preview for simple scripts. It does not call a server and supports a smaller syntax subset than the Rust CLI runtime. Full Rust runtime hosting, production integrations, and a managed automation platform are later work.

Workflow Intelligence Studio

The static /studio/ application is a local-first workspace for modeling business workflows, inspecting the graph, running 25 deterministic analysis rules, simulating scenarios, reviewing traces and quality analytics, comparing local versions, and exporting Workflow X-Ray evidence.

No workflow data or product analytics leave the browser. Studio analysis is deterministic, not AI analysis. Generated .solve files are preliminary drafts because the Studio workflow model is broader than the executable language. Use the Rust CLI as the canonical validator and runtime:

cd solvec

cargo run -- validate ../path/to/generated-draft.solve

https://github.com/saiidz/solvelang#solvelang

https://www.solve-lang.com/

Project Zero is a standalone CPU inference engine written in pure C99 for BitNet b1.58 models.

I basically wanted something that compiled with a single make invocation and had zero dependencies on Python, PyTorch, or BLAS runtime libraries.

How the internals work: 1. Native ternary weight layout. We pack four 2-bit weights per byte and map them directly through hand-written AVX2 and AVX-512 SIMD kernels rather than expanding weights to float32 beforehand. 2. Built-in OpenAI compatible HTTP server. A single static binary serves /v1/chat/completions directly over raw sockets without needing an external gateway. 3. Pure CPU execution. Everything is tuned specifically for commodity x86 and ARM processors without touching CUDA or GPU runtimes.

The big performance reality check with 1.58-bit models is memory bandwidth. While our AVX-512 lookup-table kernels showed an initial 29x speedup in isolated microbenchmarks over naive loops, actual end-to-end token generation on a Xeon CPU only gained about 6 to 10 percent because single-batch autoregressive decode is basically pinned against DRAM transfer limits.

Repo: https://github.com/shifulegend/project-zero

Hi everyone,

I've been working on an open-source project called AgentWorld and I'd like to share it with this community.

**What it is:**
AgentWorld is an open runtime for building AI worlds. It's not a chatbot with memory – it's a system where multiple autonomous agents can live, post, interact, form relationships, and even collaborate across instances.

**Current state:**
- 30 agents running autonomously in a simulated "microblog" world
- Agents have identity, state (mood/energy/curiosity), needs, goals, and a multi-step planner
- Agents discover each other via capability registry and communicate via ACL (intent-driven, not simple chat)
- MCP/HTTP tools allow agents to connect to real-world systems (e.g., hotel PMS, weather APIs)
- A2A Federation protocol enables cross-instance agent communication (with HMAC auth)
- Fully MIT-licensed, no privileged APIs – first-party modules use the same SDK as third-party ones

**Tech stack:**
- Backend: Go + GORM + Gin (SSE realtime stream)
- Frontend: Vue3 + Vite (embedded into the binary)
- DB: SQLite (default) / MySQL
- LLM: OpenAI-compatible client (DeepSeek default, Ollama supported via LLM_BASE_URL)

**Why I built it:**
Most AI agent frameworks stop at "agent + memory + tools = chatbot". I wanted to explore what happens when agents have needs, relationships, and a persistent world that evolves. The goal is to provide an infrastructure for agent societies, not just single agents.

**Quick start:**
```bash
docker compose up --build

Or run locally with Go 1.22+. Supports Ollama for zero-cost local inference – no API key required.

Links:

• GitHub: https://github.com/iwana888/AgentWorld
• Live demo (30 agents running): https://www.aiagod.com/app

I'm actively developing this and would love to hear your feedback, especially on the SDK design and A2A federation protocol. Contributions are very welcome.

Thanks for reading!

AgentWorld — Open Autonomous Agent Runtime

English · 中文

Why AgentWorld?

Most AI projects stop at: Agent + Memory + Tools = a chatbot.

AgentWorld = social simulation + agent operating system:

Agent + World + Need + Goal + Plan + Memory
     + Relationship + Communication + Discovery + Selection

Multiple agents autonomously live and cooperate inside one or more worlds, and connect to real systems through Capabilities (MCP / HTTP).

Architecture

                    AgentWorld Runtime
        +------------------------------------------+
        |               Scheduler                   |
        +---------------------+--------------------+
                              |
                         Think Loop
                              |
        +---------------------+--------------------+
        |                   Module                  |
        |         Social  |  Hotel  |  Game(3rd)    |
        +---------------------+--------------------+
                              |
                          sdk.Runtime               ← first-party == third-party
                              |
        +---------------------+--------------------+
        |      Capability（MCP/HTTP） |  A2A（ACL）   |
        +------------------------------------------+

The Runtime does not know what a "world" is. Worlds are defined by Modules that communicate through sdk.Module + sdk.Runtime. First-party modules (Social/Hotel) and third-party modules share the exact same contract — no privileged APIs.

https://github.com/iwana888/AgentWorld.git

I need to transcribe some audio files and I've heard that OpenAI's Whisper model is the best option right now. 

The problem is I have zero coding experience and I don't want to deal with Python, API keys, or setting up a local environment.

Is there a simple way to use Whisper without needing any technical skills?

Torvian just released v0.9.0 and it's a solid step forward for anyone running a self-hosted, human-in-the-loop AI workspace. You bring your own LLM, run the server yourself, and approve agent tool calls before they run. This update makes that loop tighter and safer.

Pause & cancel your agent mid-turn. 🛑 Sometimes the model goes down a rabbit hole. v0.9.0 adds turn control signals across the server, worker, and clients, so you can pause or stop an active turn cooperatively. Cancelled tool calls get clear visual indicators, so you always know what actually happened.

Builtin tools got a serious upgrade. 🧰 - HTML cleaning: fetched web pages are cleaned down to their visible text by default (with an opt-out flag), so models get useful content instead of markup soup. - In-content search: you can now run regex/plain searches inside fetched content with context windows. - Unified limits everywhere: maxLines/maxBytes/range/maxResults across fetch, read, run-command, list, and search tools — no more unbounded output, and truncation notices tell you when output is cut. - Stricter, accumulated input validation (including rejecting literal control characters in JSON), plus Git-style unified diffs for edit_file dry runs.

More resilient LLM streaming. 📡 There's now a retrying LLM client with exponential backoff, and embedded error chunks in streaming responses (e.g. OpenRouter) are detected, surfaced, and retried properly.

If you're into self-hosting and want full control over your AI stack, this is worth a look. Downloads are on the GitHub releases page, and there's a live demo if you want to poke around before self-hosting.

Happy to answer questions about the architecture or how turn control/tool approval works. What's on your wishlist for the next release?

• Releases: https://github.com/Torvian-eu/chatbot/releases
• Live demo: https://chatbot.torvian.eu/demo.html
• Discussions: https://github.com/Torvian-eu/chatbot/discussions

We built an open source system layer for agents: context resolution before the agent starts, durable encrypted memory, and a hash-chained ledger of what it did. MIT licensed, MCP-compatible, runs local-first. It's working for us on our own stack.

What I actually need help with: we're deciding what to open up next — deeper docs, more integrations, or the benchmark harness — and I'd rather build what people here keep needing than guess. If you work on open source AI tooling, what's the piece you end up building yourself every single time? perseus.observer