Frugal Orchestrator

Token-efficient task orchestration system that delegates work to specialized subordinates while prioritizing system-level solutions over AI inference.

Security Scan

The code and instructions broadly match an orchestration purpose, but there are packaging inconsistencies and a few behaviors (unspecified git pushes, reading/including local file contents in delegation messages, missing referenced files) that do not align cleanly with the SKILL.md and raise caution before installing.

Purpose & Capability

The name/description (token-efficient orchestration) align with the included modules (router, cache, batch, A2A, learning). However SKILL.md/README claim many more files (demo, tools/toon, 58 files) and a GitHub repo version v0.5.0 while the registry metadata shows v1.0.1 — the packaged manifest only contains ~18 files. Several README/quick-start actions reference files or directories not present in the manifest (demo/, tools/toon/*), suggesting the bundle is incomplete or mismatched with its documentation.

Instruction Scope

Runtime instructions and scripts perform local file I/O under /a0/usr/projects/frugal_orchestrator (logs, cache, metrics) which is expected. Concerns: delegate.sh will cat a provided context file and embed its contents into the outgoing 'agent_call' JSON (possible sensitive local-file disclosure if invoked with an arbitrary context path). phase5_automation.sh and integration_harness.sh run git commands (including git push) and expect tools/toon utilities — these can transmit repository content to a remote origin without any declared credentials or warnings. integration_harness uses eval to run tests (shell evaluation of arbitrary commands), increasing risk if tests or inputs are tampered with.

Install Mechanism

There is no install spec (instruction-only skill). That lowers installer risk because nothing is downloaded during an automated install. However the skill includes many executable scripts that will be written to disk when the skill is installed by the agent — review them before running.

Credentials

The skill declares no required env vars or credentials, which is reasonable for local orchestration. However multiple scripts call out-of-band operations that typically require credentials (git push, potential network calls via curl, or platform-specific 'call_subordinate' tools). Those credentials are not declared here — the skill may fail, or if credentials are present in the environment they could be used for network operations. The skill writes and reads project-local files but does not explicitly request access to other systems.

Persistence & Privilege

always:false and normal autonomous invocation are used. The skill writes and manages files under its own project directory (logs, cache, metrics) which is within scope for an orchestrator. It does not request elevated system-wide privileges or modify other skills' configurations.

What to consider before installing

This skill mostly implements what it claims — routing, caching, batch processing — but the package appears incomplete and includes actions you should review before enabling. Before installing: 1) Verify the source/repository (SKILL.md references a GitHub repo but the registry source is unknown). 2) Inspect scripts you will run, especially delegate.sh, delegate_complete.*, phase5_automation.sh, and integration_harness.sh. Delegate.sh may read and embed a supplied file's contents into an outgoing message — do not pass sensitive file paths. 3) Expect git operations (commit/push) and curl usage: if you have repository remotes or credentials in the environment they could be used; remove or sandbox network-facing commands if you don't trust the origin. 4) Because README/SKILL.md mention files (demo, tools/toon converters) that are missing from the manifest, treat the package as incomplete — running the demo/integration may fail or attempt to access resources not provided. 5) If you want to proceed, run it in a sandboxed environment (no access to sensitive files or credentials), or request the complete upstream repository and verify checksums and the missing utilities first.

Skill: Frugal Orchestrator

Metadata

• Name: frugal-orchestrator
• Version: 0.5.0
• Author: Agent Zero Project
• Tags: orchestration, efficiency, token-optimization, delegation, caching, batch-processing, learning
• Description: Complete token-efficient task orchestration platform with auto-routing, caching, batch processing, A2A mesh, and learning engine. Achieves 90%+ token reduction.

Problem Statement

AI agents often waste tokens on tasks better solved by system tools (Linux commands, Python scripts). This creates unnecessary costs and slower execution.

Solution: Frugal Orchestrator v0.5.0 with intelligent task routing, caching layer, and specialized subordinate delegation.

Result: 90%+ token reduction while maintaining full functionality

Core Capabilities

Module 1: Auto-Router

Purpose: Automatically detect task type and route optimally

• System commands → Terminal (95% token reduction)
• Scripts → Python/Node.js execution
• Complex logic → AI delegation
• Class: TaskRouter

Module 2: Token Tracker

Purpose: TOON-format token metrics logging

• Track delegation vs direct execution
• Generate savings reports
• Class: TokenTracker

Module 3: Cache Manager

Purpose: Content-addressable result caching with TTL

• CRC32 hash-based keys
• LRU eviction, 7-day default TTL
• Class: CacheManager

Module 4: Error Recovery

Purpose: Resilient execution with retry/fallback chains

• Exponential backoff, circuit breaker
• Classes: ErrorRecovery, FailureType

Module 5: Batch Processor

Purpose: Parallel task execution

• Concurrent worker pool
• Manifest-based processing
• Class: BatchProcessor

Module 6: A2A Adapter

Purpose: Agent-to-Agent mesh communication

• Service discovery, load balancing
• Class: A2AAdapter

Module 7: Learning Engine

Purpose: Pattern recognition for routing decisions

• Confidence scoring, history analysis
• Class: LearningEngine

Module 8: Scheduler Integration

Purpose: Recurring task scheduling

• Cron-style scheduling
• Class: SchedulerClient

Quick Start

# Run demonstration
cd /a0/usr/projects/frugal_orchestrator/demo && bash run_demo.sh

Python Integration

from scripts.auto_router import TaskRouter
from scripts.cache_manager import CacheManager
from scripts.token_tracker import TokenTracker

# Initialize
router = TaskRouter(TokenTracker())
result = router.route("file_operations", task_input)

Project Statistics

Metric	Value
Python Modules	10
Shell Scripts	6
Total Files	58
Python LOC	1,763
Token Reduction	90%+

Token Efficiency

Feature	Token Reduction
Auto-routing	90-95%
Caching	>99% for repeats
Batch processing	Linear scaling

GitHub Repository

https://github.com/nelohenriq/frugal_orchestrator (v0.5.0)

Version History

• 0.5.0: Complete orchestration platform (10 modules, full infrastructure)
• 0.2.0: Standardized agentskills.io format, Git repo
• 0.1.0: Initial implementation