Agentlas OS
Package, route, and verify portable specialist agents and teams from your local model host.
Per-dimension scores and reasoning
Evidence shows permission controls (e.g., sandboxing, anti-scope, caller-gating) and user confirmation (e.g., import as proposal), but lacks implementation details and verification. Data flow transparency is described (e.g., redacted WorkOrder, local-first), but no actual logs or audit examples. Sensitive data handling is mentioned (e.g., not storing credentials), but no concrete mechanism. Dependency security not mentioned, no dependency list or vulnerability scanning. External effects described (e.g., Telegram connection, publishing to Hub), but permission boundaries unclear. Rollback mentioned (e.g., rollback coverage), but no concrete implementation. Source attribution mentioned (e.g., digests, receipts), but no verification method.
Self-consistency is good, multiple descriptions in README are consistent (e.g., command aliases, installation methods). Dependency availability not explicit, no dependency list or versions. Failure messages mentioned (e.g., verified/unverified/blocked states), but no specific error handling examples.
Target audience clear (developers, enterprises), scenarios diverse (customer support, market reports). Capability boundaries described (e.g., anti-scope, triggers). Trigger precision described (e.g., ambiguity gates, anti-triggers). Environment fit described (supports multiple LLMs and local models).
Information architecture clear, with directory structure and documentation index. Installation instructions detailed, multiple methods. Naming stability, alias compatibility. Examples and FAQ provided (e.g., command examples). Known limitations mentioned sparingly, only some caveats. License clearly Apache-2.0. Versioning and changelog mentioned (e.g., v1.1.0), but no detailed changelog. Maintenance responsibility not explicit, no contribution guide or maintainers.
Output usability described (e.g., verified/unverified states, work brief), but no actual output examples. Marginal value described (e.g., avoiding repeated configuration, model neutrality), but not quantified. Cost-benefit not explicit, no performance or resource consumption data.
Claim traceability moderate, some claims have doc links, but no concrete evidence. Cross-source corroboration insufficient, mainly relies on README itself. Fact-inference separation unclear, not distinguishing verified facts from design intent.
- Dependency security not addressed; recommend checking dependency list and vulnerability scanning.
- Installation script via curl pipe poses supply chain risk; review script content.
- Publisher identity unverified; proceed with caution.
What does this agent do, and when should you use it?
Agentlas OS is a local-first agent runtime and packaging system built around the open-source Hephaestus engine, not a hosted model executor. It compiles plain-language requests into single-agent or team packages with roles, input/output contracts, routing cards, memory boundaries, and verification scripts. The repository documents command adapters for Claude Code, Codex, Gemini CLI, Antigravity, Cursor, and compatible local or API hosts. Network 2.0 federates exact local, private Cloud, and public Hub scopes while validating selected packages, and Stormbreaker manages gated execution and completion states. The current host, chosen model, local files, credentials, tools, and permissions perform the work; Agent Cloud stores and restores owner packages rather than running the LLM server-side.
/agentlas build sends a request through the single-agent, multi-agent-team, or workspace-packager builders and produces a package contract, including contracts/intake.schema.json, contracts/output.schema.json, contracts/output.example.json, and .agentlas/brief.json; scripts/verify-generated-package.sh <folder> checks generated packages. /agentlas network turns work into a redacted WorkOrder, obtains bounded candidate menus from local, cloud, and hub scopes, lets the active host LLM author the Selection, then validates governance, identity, cardinality, graph integrity, and immutable package digests. Stormbreaker executes a scope lock, decomposition, parallel work packets, contract verification, bounded repair, and final gate, maintaining a local run journal and reporting verified, unverified, or blocked. bin/ontology ingests local files into SQLite and queries them with FTS5, reciprocal-rank fusion, and GraphRAG; agentlas-cloud ao a2a commands support controlled A2A import/export and caller-gated routing.
- An engineering team using Claude Code or Codex that needs to split a launch plan among research, copy, QA, and release roles with explicit handoffs and verification.
- An independent developer who wants to turn a repeatable support, review, or research workflow into a portable package that can be restored from private Agent Cloud on another supported host.
- A team with a local document corpus that needs
bin/ontology ingestplus SQLite, FTS5, and GraphRAG retrieval without sending raw documents to external cloud hooks. - A user who wants to borrow a public Hub specialist without copying the publisher's private source work or sending local private files to that agent.
- A delivery owner who needs agent work to finish with deterministic checks and an explicit verified, unverified, or blocked outcome.
What are this agent's strengths and limitations?
- Uses an inspectable package contract rather than only a role prompt: schemas, routing cards, memory maps, and verification scripts have defined artifacts.
- Documents adapters across Claude Code, Codex, Gemini CLI, Antigravity, Cursor, and compatible local/API hosts, separating the package from one model workspace.
- Network 2.0 keeps local, private Cloud, and public Hub as explicit scopes and verifies selected immutable releases before execution.
- Stormbreaker combines local run journals, contract checks, bounded repair, and explicit completion states for audit-oriented workflows.
- Adoption requires a local shell, Git, and a user-provided model account or API key; this is not a turnkey hosted-model service.
- Moving a package does not move credentials, local files, or machine-specific permissions, which must be configured again on each computer.
- Cloud and Network paths can be constrained by login, credits, entitlement, or poor matches, with documented fallback behavior rather than guaranteed availability.
- The system has a broad operational surface—package contracts, adapters, routing scopes, and local permission boundaries—and the supplied material does not document complete service pricing.
How do you install or deploy this agent?
From an OS terminal, run xcode-select --install if command-line tools are missing, then git --version, followed by curl -fsSL https://raw.githubusercontent.com/agentlas-ai/Agentlas-OS/main/scripts/install-all-runtimes.sh | bash. The installer places the shared runner at ~/.agentlas/runtime/current/bin/hephaestus and registers adapters for supported hosts. To install ordinary-prompt routing, run hephaestus global install; it manages marked blocks in the Codex, Claude Code, and Gemini/Antigravity instruction files and normally writes timestamped backups. Private Cloud retrieval requires signing in on a supported host with Agentlas OS installed. Execution also requires a model account or API key chosen and configured by the user.
How do you use this agent?
In an external LLM host, begin with /agentlas search find agents for a market report workflow; build a package with /agentlas build create a customer support agent for Shopify refunds; or orchestrate a multi-role request with /agentlas network split this launch plan into research, copy, QA, and release agents. Use /agentlas local, /agentlas cloud, or /agentlas hub to restrict work to registered local packages, owned Cloud packages, or public Hub packages. In Codex 0.117+, invoke documented plugin skills such as $hephaestus-network <request> and $hephaestus-build <request> rather than the removed custom /prompts:* commands.
How does this agent compare with similar options?
The repository positions CrewAI, LangChain, and vendor agent SDKs as libraries for custom logic within a single process, while positioning Hephaestus as a runtime substrate for specifying, packaging, routing, running, auditing, and migrating agent packages. It also distinguishes an Agentlas package from a Claude-style prompt-made agent by adding routing, memory, team roles, verification, and portability boundaries.
FAQ
Does Agentlas Cloud run the model for me?
Do credentials and local files move with a package?
What happens when work cannot be verified?
Must I use the public Hub?
network is their combined scope.