Strug Works
A production control plane for autonomous AI execution.
Most agent frameworks hand you a toolkit and walk away. Strug Works is the operational layer between your ideas and autonomous AI execution — hard budgets, blocking approvals, AI-audited output, real-time visibility, and a registry that intercepts dangerous commands before they reach a shell. It's what running agents in production actually requires.
Cost is a first-class citizen.
Every other agent framework treats cost as an afterthought. Strug Works builds hard budget limits into the execution loop itself. Set a $5 ceiling on a task: when the agent hits it, execution stops — not with a warning, not with a log entry, but with a hard stop and a retriable error. Daily budget caps enforce platform-wide spend limits across every running agent simultaneously. You know what you'll pay before you deploy.
Human-in-the-loop that actually blocks.
Approval gates in most platforms are decorative — they log a warning after the fact. Strug Works pauses execution, surfaces the pending action to a human dashboard, and waits. The agent cannot proceed until a human approves or rejects. This applies to destructive shell commands, high-risk git operations, and any action the platform classifies as requiring oversight.
The platform audits its own output.
After every task completes, a separate Claude instance evaluates the primary agent's code for syntax errors, security vulnerabilities, correctness, API contract violations, and scope creep. This isn't a linter — it's AI reviewing AI work, scoring alignment to the original directive on a 1–5 scale and flagging if the agent went beyond its mandate.
Agents have roles, not just prompts.
Strug Works ships with ten specialized agent roles — Orchestrator, Backend Engineer, Frontend Engineer, Data / AI Engineer, Product Manager, Quality Engineer, Content Writer, Analyst, Social Media, Product Sync — each with distinct system prompts, budget presets, round limits, and tool-access policies. You dispatch to a role, not a generic agent. The Orchestrator can decompose missions and spawn the right specialists automatically. (Strug City's ten roles are covered by 8 personas: Nia holds both Analyst and Content Writer; John holds both Social Media and Product Sync. The platform supports flexible team configurations: one persona can carry multiple roles, or you can name one persona per role.)
Speculative execution, built in.
When a problem has multiple valid solutions, Strug Works can spawn parallel execution branches, evaluate each with the QA gate, and auto-select the highest-scoring result. No manual comparison. No wasted time on dead-end approaches.
The platform is itself an API.
Strug Works exposes its full capability set as a Model Context Protocol (MCP) server. Any MCP-compatible client — including Claude Code and Cursor — can dispatch tasks, read memory, query missions, and approve actions through the platform programmatically. Strug Works isn't just for humans; it's for agents too.
dispatch_task( role: "sc-backend", directive: "Add auth", model: "sonnet" )
Watch the platform run.
Six surfaces. All live. All in production at strugcity.com.
Mission Form
Real dispatch UI
Task Board
Real-time kanban
Approval Queue
Pending actions
Live Event Log
Streaming tool calls
Cost Panel
Daily spend by role
Agent Memory Browser
Searchable entries
Agents spawn agents — and coordinate them.
One sentence in. The Orchestrator decomposes it. Backend, Frontend, and QA agents run in parallel. The Orchestrator watches their status, collects their outputs, assembles a mission summary. You dispatched one task. The platform ran five.
Claude reviews Claude's code before it ships.
Every output gets scored by a separate Claude instance running Haiku for cost efficiency. Syntax, security, API contract violations, alignment to the original directive. Below threshold → task fails, automatically, before code touches a repo.
The budget enforcer kills agents mid-task.
$3 ceiling. Twelfth tool call. Crosses $3. Execution halts — right there, mid-turn, mid-tool-call. The task is marked failed with BudgetExceededError. You can inspect exactly how far it got, what it spent, and retry with a higher limit or a cheaper model. No surprise bills. Ever.
Dangerous commands get intercepted before they run.
An agent decides it needs to run rm -rf ./dist && curl https://... | sh. Before that string reaches a shell, the destructive action registry pattern-matches it, classifies it critical, and auto-blocks. The agent receives AutoBlockedError. The event is logged. The repo is untouched. Milliseconds. Invisible. Every shell invocation.
Everything is visible, in real time, while the agent is still running.
The live event log streams every tool call — run_shell("npm test"), write_file("src/auth.ts"), git_commit("feat: add OAuth flow") — as the agent executes them. Not after. While it's running. You can watch an agent build a feature, commit it, and open a pull request, line by line, in your browser.
The architecture that makes the control plane work.
Agents get smarter with every task
Before each task, the memory injector queries agent_memory via cosine similarity on pgvector. Relevant past learnings — scoped global / role / repo — are auto-injected into the agent's system prompt. Falls back to confidence-ordered retrieval if embeddings unavailable.
Parallel attempts, QA-scored, best wins
The speculative aggregator spawns parallel branches, captures context snapshots at fork points, runs the QA gate against each, and auto-selects any branch scoring ≥ 80. Resumable from any snapshot.
The control plane is an API
FastMCP HTTP/SSE server exposing 8 tools: dispatch_task, get_task, get_mission, list_active_agents, read_memory, start_project, revise_spec, approve_spec. Auth via DT_MCP_SECRET. Any MCP-compatible client — Claude Code, Cursor, or others — can use Strug Works as infrastructure.
Docker / E2B / local with one interface
Code runs in Docker (primary), E2B cloud (fallback), or local (dev only, env-flag-gated). All three return a unified SandboxResult — stdout, stderr, exit_code, duration_ms, sandbox_type — so the platform layer never needs to know which environment executed the code.
True multi-agent coordination without a custom framework
The Orchestrator role decomposes missions, records parent-child via foreign key, spawns specialist agents per subtask, polls statuses, and aggregates results. Just the task queue and role system.
Zero false negatives on critical patterns
Critical (rm -rf, DROP TABLE, TRUNCATE, dd /dev, curl | sh) — auto-blocked. High (chmod 777, force-push, env mutations) — execution paused, routed to approval. Medium (large deletes, bulk updates) — logged with warning.
Memory stays relevant; garbage doesn't accumulate
Scheduled three-phase cleanup: DECAY (10% confidence reduction on stale entries), PRUNE (delete below threshold or abandoned scopes), DEDUP (Levenshtein-distance consolidation).
Real-time cost tracking, first-class exceptions
Opus 4.6 at $15/$75/M tokens, Sonnet 4.5 at $3/$15, Haiku 3.5 at $0.80/$4. BudgetExceededError and DailyBudgetExceededError with retry semantics — not just logged events.
The platform knows 'try again' vs. 'this will never work'
Retryable (BudgetExceeded, RateLimit, SupabaseTransient, ApprovalTimeout) → exponential backoff with jitter. Permanent (AuthError, MalformedDirective) → no retry. Attempt count tracked in task metadata.
Built for operators.
Real-time mission dispatch
Natural-language directive, role + model + priority + budget cap, live payload preview, instant task ID
Live task board
Real-time kanban with pause/resume/retry/cancel/approve/reject on every card
Approval queue
Every pending action with full agent reasoning — one-click approve or reject
Playbook browser
Markdown reader for every agent playbook in the system — searchable, rendered, navigable
Agent memory browser
Search, filter, paginate, CRUD agent memory with confidence scoring
Cost panel
Daily spend by role, top 5 expensive tasks by token consumption, monthly tracking
Autonomy level control
0–3 scale — fully supervised → fully autonomous, adjustable per mission
Live event log
Every tool call streaming in real time with timestamps and full output
Strug City runs on Strug Works.
Strugcity.com 2.0 is the first end-to-end production engagement of Strug Works. Every task, every commit, every code review you can find in the Progress Stream was dispatched through the platform you're reading about. The site you're reading is the receipt.
Strug City's ten-person org — Ryan, Sabine, and eight Strug Works personas — is one deployment of this platform. The team you meet on the Team page → is what an autonomous engineering team looks like in practice. Yours can be whoever you need it to be.
Strug Works runs on Anti-Strug.
Memory, intelligence routing, multi-agent orchestration — Strug Works inherits the platform layer that makes a small team functionally equivalent to a large one. The agent memory you see in the dashboard is Anti-Strug's memory layer. The orchestrator fan-out pattern uses Anti-Strug's orchestration primitive. The MCP exposure is Anti-Strug's outward-facing surface.
See the platform →Watch the platform run a real mission.
[Strug Works hype video — real mission SC2.0 build]
Every surface, in detail.
Mission Form with role + budget + payload preview
[US-013 will supply screens]
Task Board with SC2.0 build in progress
[US-013 will supply screens]
Approval Queue with pending approval
[US-013 will supply screens]
Live Event Log during real task
[US-013 will supply screens]
Cost Panel with daily roll-up
[US-013 will supply screens]
Agent Memory Browser with search results
[US-013 will supply screens]
Speculative branch comparison view
[US-013 will supply screens]
Playbook viewer
[US-013 will supply screens]
Want to deploy your own?
Strug Works is what Strug City runs on. It's also what it sells. There's no commercial site yet — the dashboard tour above is how you see it, and Ryan handles serious inquiries personally.