Draft:Openwalrus
This is a draft Articles for creation (AfC) submission. It is not currently pending review. While there are no deadlines, abandoned drafts may be deleted after
 | Draft article not currently submitted for review.
This is a draft Articles for creation (AfC) submission. It is not currently pending review. While there are no deadlines, abandoned drafts may be deleted after six months. To edit or make changes to this draft, simply click on the "Edit" tab at the top of the window. To be accepted, a draft should:
It is strongly discouraged to write about either yourself or your business or employer. If you do so, you must declare it. Where to get help
How to improve a draft
You can also browse Wikipedia:Featured articles and Wikipedia:Good articles to find examples of Wikipedia's best writing on topics similar to your proposed article. Improving your odds of a speedy review To improve your odds of a faster review, tag your draft with relevant WikiProject tags using the button below. This will let reviewers know a new draft has been submitted in their area of interest. For instance, if you wrote about a female astronomer, you would want to add the Biography, Astronomy, and Women scientists tags. Editor resources
Last edited by Bearcat (talk | contribs) 5 months ago. (Update) |
| OpenWalrus | |
|---|---|
| Developer | clearloop |
| Release | March 8, 2026 |
| Stable release | 0.0.5
|
| Written in | Rust |
| Operating system | macOS, Linux |
| Type | AI agent runtime |
| License | GPL-3.0 |
| Repository | github |
OpenWalrus is a free and open-source AI agent runtime written in Rust. It is designed to run autonomous AI agents entirely on local hardware, with built-in large language model (LLM) inference, eliminating the need for cloud-based API calls.[1] The project follows a local-first architecture in which agents operate as a background daemon on the user's machine, with no network services exposed by default.[1]
OpenWalrus is distributed as a single binary with no external dependencies such as Docker or database servers. It supports macOS (Apple Silicon and Intel) and Linux (x86-64 and ARM).[1]
History
OpenWalrus was created by clearloop, a software developer, and publicly released on March 8, 2026, under the GPL-3.0 license.[1] The project was motivated by what its developers described as systemic problems with existing cloud-based agent runtimes, including high API token costs, security vulnerabilities from exposed network services, complex multi-service deployment requirements, and supply-chain risks from unvetted plugin ecosystems.[1]
The software is published to the Rust package registry (Crates.io) under the package name openwalrus.[2]
Architecture
OpenWalrus is structured as a Cargo workspace composed of several crates:[1]
| Crate | Purpose |
|---|---|
walrus-core |
Agent execution, runtime, sessions, hooks, model trait definitions |
walrus-model |
LLM provider integrations (local inference, OpenAI, Claude, DeepSeek) |
walrus-daemon |
Background service, graph memory, task registry, permissions, event loop |
walrus-channel |
Telegram and Discord messaging integrations |
walrus-socket |
Unix domain socket transport |
openwalrus |
Command-line interface and REPL |
The runtime operates as a background daemon that manages agents through a single mpsc::unbounded channel. Each incoming event—whether from a CLI session, a Telegram message, or a tool call result—is dispatched as an independent asynchronous task, so agents do not block each other.[1]
Local LLM inference
OpenWalrus integrates mistral.rs, a Rust-native LLM inference engine, to run language models in-process without requiring external API calls.[1] A built-in model registry includes over 20 curated models from families such as Qwen, LLaMA, Gemma, Mistral, and Phi. The runtime auto-selects the appropriate model and quantization level based on the user's hardware.[1] Users may also connect remote LLM providers (OpenAI, Claude, DeepSeek) as an optional supplement.[1]
Graph-based memory
Agent memory is backed by LanceDB with a graph layer provided by lance-graph. The system maintains three tables: entities, relations, and journals. Six built-in tools—remember, recall, relate, connections, compact, and distill—allow agents to build, query, and traverse a knowledge graph during operation. Agent identities and recent journal entries are automatically loaded into the system prompt at session start.[1]
Sandbox and permissions
OpenWalrus implements workload isolation using operating system-level mechanisms rather than containerization. A dedicated OS user is created via the walrus sandbox init command, and agents execute under this user identity. Standard Unix file permissions and ACLs enforce the security boundary. Specific files and directories are shared with agents via walrus sandbox share.[1]
Features
- Skills system — extensibility through Markdown files with YAML frontmatter that define agent behaviors, discovered via tag-based search. Three tiers: bundled (shipped with the binary), managed (community hub), and workspace (user-defined).[1]
- Task registry — a runtime primitive for multi-agent coordination with five task states (queued, in_progress, blocked, finished, failed), concurrency limits, timeouts, and an approval flow. Live task state is viewable via
walrus ps.[1] - Messaging channels — built-in integrations for Telegram (via teloxide) and Discord (via serenity) with per-channel persistent sessions.[1]
- Browser control — deterministic web navigation, form filling, and data extraction.[1]
- Model Context Protocol (MCP) — support for connecting external tool servers via the MCP standard.[1]
- Lifecycle hooks — four hook points for injecting custom logic into agent execution.[1]
Design philosophy
The project's stated design principle is "less code, more skills"—keeping the runtime core compact while pushing extensibility to skill files rather than framework code.[1] The developers cite research suggesting that frontier LLMs reliably follow approximately 150–200 instructions in a system prompt, with adherence degrading beyond that threshold, as motivation for avoiding system prompt bloat.[1]
Other design principles documented by the project include:[1]
- Memory as an emergent property of tools rather than a hardcoded subsystem
- Plans expressed as skills (prompts) rather than runtime primitives
- Task state maintained in an in-memory registry (
DashMap) rather than persisted to disk during execution
See also
References
External links
Category:Free software programmed in Rust Category:Free and open-source software Category:2026 software Category:Cross-platform software
Content Disclaimer
Informasi ini disarikan dari Wikipedia dan disajikan kembali untuk tujuan edukasi. Konten tersedia di bawah lisensi CC BY-SA 3.0. Kami tidak bertanggung jawab atas ketidakakuratan data yang bersumber dari kontribusi publik tersebut.
- The information displayed on this website is sourced in part or in whole from Wikipedia and has been adapted for the purpose of restating it. We strive to provide accurate and relevant information, however:
- There is no guarantee of absolute accuracy. Wikipedia is an open, collaborative project that can be edited by anyone, so information is subject to change.
- It is not intended to constitute professional advice. The content displayed is for informational and educational purposes only. For important decisions (e.g., medical, legal, or financial), please consult a professional.
- Content copyright. Wikipedia is licensed under the Creative Commons Attribution-ShareAlike License (CC BY-SA). This means that content may be reused with appropriate attribution and shared under a similar license.
- Responsible use. Any risk arising from the use of information from this website is entirely the responsibility of the user.