Weekend Projects: 3 Builds for Safer Agents + Better Workflows

This week was all about something I learned the hard way in the trades: tools are only useful when they’re safe and predictable. AI agents are the same. You don’t want a “smart helper” that can accidentally delete files, spam customers, or burn your budget overnight.

OpenAI’s latest Agents SDK update leans into this reality with sandboxing (run agents in controlled environments) and a harness designed to work with files and approved tools inside a workspace (TechCrunch). On the no-code side, Make’s “next generation” AI Agents push for visibility: a reasoning panel that shows what the agent is doing, plus multi-modal file inputs/outputs right in the automation canvas (Make).

Here are three weekend builds that take those ideas and turn them into something you can ship.

Project 1 — A sandbox-first agent runner (local dev)

• Time: 4–6 hours
• Tools: Docker (or Podman), Python, and your LLM API of choice

What you’ll build: A tiny “agent harness” that can only read/write inside one folder, can only run a short allow-list of commands, and logs every tool call. Think of it like putting a guardrail around a job site before you start cutting steel.

How to build it:

1. Create a container that mounts a single working directory (e.g., /work).
2. Implement tools with strict path checks:
   • read_file(path) and write_file(path, content) only under /work
   • run_cmd(cmd) only for commands like pytest, ruff, npm test, etc.
3. Log each action to JSONL: timestamp, tool name, arguments (redacted if needed), and result summary.
4. Give the agent one bounded task, like “Fix failing tests” or “Format this repo and open a PR.”

What you’ll learn: why sandboxing + an explicit tool allow-list is the real foundation for “long-horizon” agent work. You’ll also learn what telemetry you need to debug agents when they fail.

Project 2 — Quote-to-invoice workflow: automation first, AI only where it helps

• Time: 3–5 hours
• Tools: Make.com (or n8n), Google Docs/PDF, QuickBooks/Xero integration (or a CSV export), email/SMS

What you’ll build: A reliable workflow that turns a quote approval into an invoice and a follow-up schedule. Most of this is automation (rule-based steps). Use AI only for the parts that change job-to-job (e.g., turning rough notes into a clean scope line item).

Build steps:

1. Trigger (automation): “Quote accepted” form submission or CRM status change.
2. AI step: Take free-form notes (from the estimator or tech) and generate:
   • a clean customer-facing scope summary
   • 3–6 line items with quantities/units (you’ll review before sending)
3. Human checkpoint: Send a draft invoice preview to you in email/Slack for approval.
4. Automation: After approval, create the invoice, send it, and schedule follow-ups at day 3/7/14.

What you’ll learn: how to keep an “agentic” tool honest by putting it inside a visible, step-by-step workflow. Make’s point about radical transparency matters here: you want to see decisions, not guess at them (Make).

Project 3 — A cost-and-risk budget for agent runs

• Time: 2–3 hours
• Tools: Any agent framework (or your own harness), a simple SQLite DB, and a dashboard (optional)

What you’ll build: A “job budget” system: every agent run gets a max tool count, max tokens (or max spend), and a hard stop if it drifts. This is the boring part that keeps your margins intact.

Implementation idea:

• Define a run config like:

  {
    "max_tool_calls": 40,
    "max_minutes": 8,
    "max_usd": 1.50,
    "allowed_tools": ["read_file","write_file","http_get","send_email_draft"],
    "requires_human_approval": ["send_email","create_invoice","delete_file"]
  }
  

• Store every run in SQLite: inputs, outputs, spend estimate, and whether it hit a stop condition.
• Add a “replay” mode that re-runs the same steps in dry-run (no external side effects) so you can debug safely.

What you’ll learn: how to keep long-running agents from turning into “infinite loops with a credit card.” The sandboxing + harness direction OpenAI is talking about exists for a reason (TechCrunch).

If you build one of these, start small: one folder, one workflow, one approval gate. In the real world, reliability beats clever every time.