V1 launches
26·08·2026
We are building the website for MySynergy — a packaging company focused on packaging engineering, rapid prototyping and supplier coordination.
We run our own work on an agentic workflow, so the website goes up the same way the rest of our work does. The build log below this hero is everything we have shipped along the way.
000
Days
00
Hours
00
Minutes
00
Seconds
Counting down — Hong Kong time, UTC+8
27 entries · last updated 4 JUL 2026
You found mysynergy.technology — our public face. We are about eight weeks out from V1 going live, so for now this is a countdown clock and a build log.
The countdown above is real. The build log below this card is what we have shipped so far. We would rather show what we are doing than tell you what we plan to do.
If you are a candidate for the 2026 internship: applications open 1 May 2026, 20:00 HKT.
Our AI agents each act under their own identity on a shared system of record — when one writes something, it's stamped as that agent, not a shared login. This week we found that three of them had been quietly convinced they couldn't do something they'd been able to do for months. Nothing errored. Their access was real and had been all along — but their operating instructions still read "you don't have this; hand it to someone else." So, faithfully, they did.
An agent that believes it lacks a permission behaves exactly like an agent that lacks it. The capability was real; the self-knowledge was missing — and for an autonomous system those are the same thing. We fixed the instruction, then re-ran each agent and asked it, cold, what it could do — because editing a document doesn't prove the agent understood it. The answer flipped from "I have to route this through someone else" to "I do this myself, and every action is stamped as me."
The instruction had drifted in the first place because there was no single source of truth — the guidance had been hand-copied to each agent and the copies quietly diverged. So the durable fix wasn't the wording. It was collapsing everything to one canonical copy, and giving each agent a way to ask the system directly "who am I, and what can I touch?" instead of trusting a list that goes stale.
We watch credentials and networks like infrastructure. This was the reminder that what an agent believes it can do is infrastructure too — and a stale sentence is an outage that never pages anyone.
For months our AI agents could do work but couldn't remember it. Every order, price, and supplier note lived only in spreadsheets.
Over the last few days we wired up "Paperclip" — a real database backbone behind the fleet:
• A live Postgres database that holds the actual order/finance data
• An always-on service that syncs it both ways with our spreadsheets every 10 minutes
• A hard budget stop so a runaway agent can't rack up cost
• A built-in firewall so cost data and price data never sit in the same place
Result: the agents now read and write to a single source of truth instead of guessing. We ran it in shadow mode (watching, not touching the real books) and got a clean go/no-go to proceed — with cutover held until we're sure.
Building in public, one layer at a time.
We've been evaluating an open-source agent-orchestration framework to sit under our own fleet. The tempting move is to adopt the whole thing and refactor later. We did the opposite — read it one layer at a time, and held all adoption until we actually understood each layer.
So far we've mapped three: orchestration (how agents take work and report back), persistence (an 85-table data model with a real two-ledger split between cost and price), and execution (how a task actually runs). Each layer taught us where it fits us and where it doesn't — its model assumes software repos and diffs; our deliverables are physical packaging and documents, so parts of it map cleanly and parts don't.
The discipline is the point. Understanding before adopting is slower up front and far cheaper than ripping out something you bolted on before you understood it.
Automating a step that moves money is where automation earns its scary reputation. So we drew the line on purpose: automate everything up to the irreversible act — and never through it.
When a transaction is ready, the system now prepares the financial document on its own and checks it against every rule. Then it stops. Nothing is committed until a person approves it, and up to that point it has written nothing that counts. The machine does the preparation; the human keeps the decision.
The part we're proud of is what approval actually means here. It isn't a rubber stamp on a snapshot taken minutes or hours ago. At the instant you approve, the system re-checks the live state against what it proposed — and if anything has moved since it asked, it cancels itself and asks again rather than acting on stale numbers. Approving the present, not the past.
Around all of it: the pipeline runs against a sandbox set of books first, never the real ledger; it keeps a hard wall between cost data and price data; and when something doesn't reconcile, it raises a flag instead of guessing. Automation should be most aggressive where mistakes are cheap, and most humble where they're permanent.
A backup built on the same foundation as the thing it protects isn't really a backup. If your primary system goes down because its provider had an outage, a standby running on that same provider is already down too. You find out the redundancy was an illusion at the worst possible moment.
So we built our orchestration agent a standby that runs on a different AI provider entirely — on purpose. When the primary can't be reached, the standby automatically picks up the channel and holds it in a deliberately narrow role: report status, triage, point a human to the fix, and refuse anything heavier. It keeps the lights on for a few hours, not the whole operation, and it steps back the moment the primary recovers.
The unexpected dividend was the second mind. Because the standby is a genuinely different model, not a copy of the first, it makes a real independent reviewer. On its first real task we pointed it at a system the primary had just built — and it immediately found a live bug the primary couldn't see in its own work.
Redundancy only counts if it fails differently from the thing it's backing up. And a second opinion is only worth having if it can actually disagree.
Most automation reads a spreadsheet, does something elsewhere, then writes a result back. We turned that inside out. The sheet isn't a data source the agent visits — it's the room the agent lives in.
An agent assigned to a sheet watches its own rows, acts when one changes, and writes its work back in place. The sheet is the interface, the queue, and the audit trail at once — what you see is exactly what the agent sees.
The guardrails aren't prompts politely asking it to behave. They're deterministic code gates around every write: an agent can only touch its own rows, only the columns it owns, and every change is logged. We ran it overnight against dozens of adversarial scenarios — zero improper edits.
When the operating surface is the same one your team already reads, nobody has to ask the agent what it did. It's right there.
A purchase order is a promise of quantity. We track every one through four states: received → placed → shipped → invoiced.
The golden rule: for each component, everything placed to suppliers over time = ordered quantity × bill-of-materials factor. When the deal closes cleanly, ordered = placed = shipped = invoiced.
The math is the easy part. The real work is the exceptions: multi-part assemblies, parts dual-sourced across two suppliers, a BOM that lags what was actually bought, one invoice covering several deliveries. The rule handles ~90% deterministically. For the other 10%, the agent flags for help instead of guessing — asking is a feature, not a failure.
Handed the agent fleet 10 real business transactions and told it to replay them end-to-end. Each agent owned one slice of the work. I didn't touch a thing — watch-only.
Result: data 100% correct across all 10. Margins computed, no duplicates, every record matched its source.
But the automated checker passed 0 of 10 — flagged "missing evidence" on every single one.
The catch: the fleet wasn't wrong. My checker was. The evidence-matcher missed files named for the base order number when the line carried a suffix. The agents did their jobs; the scaffolding I wrote to grade them had the bug.
Building in public means publishing that part too.
Spent the day putting a real persistence layer under a multi-agent fleet. Three things I wanted to prove, all held.
• Structural firewall. Cost data and price data live in two separate ledgers — they physically cannot touch. The only place they meet is one audited sync, and margin is computed only at that join. You can't accidentally leak a supplier cost into a customer-facing number.
• Shadow, not cutover. Bidirectional sync every 10 minutes against the system-of-record, which stays the single source of truth. The new layer mirrors; it never overrides.
• A budget that actually stops. Set a hard spend cap, then had an agent try to run anyway. The system rejected it before any execution — no run, no cost.
Verdict: foundation go, no cutover. Earn trust in shadow first.
We stopped forcing big builds out of chat and into a terminal. Our operator now completes large multi-step builds inline, in the same Telegram thread he talks in — no turn-caps, no SSH handoff that snaps the workflow mid-build. Tooling should bend to where the work actually happens. Backed by a 1-year headless auth token that ended the recurring 8-hour outages.
Our agent's Telegram channel had run 7–16s for three months, then suddenly went sluggish. Instinct says redesign. Wrong move. We pulled the time-series, found a hard cliff at one specific change (an async-worker rewrite), and reverted just that. Back to ~4s.
Lesson: when something with a long working history breaks, it's a regression — find the cliff, don't redesign the system.
This week our ops intern is running structured 1:1 discovery interviews across the supply chain — sales, sourcing, regional ops, design. One session a day, sequenced so each conversation builds on the last.
Each interview is built around a single opener — "walk me through your actual day-to-day" — then probes where the real work lives: the decisions that happen off-sheet, the tacit knowledge nobody's written down, the manual workarounds.
The output isn't notes. It's a ranked shortlist of which workflows an agent can take over next.
Our first 2026 intern started 1 June, working inside the agent fleet — out in the field and with suppliers across China and Vietnam, feeding real ground-level detail back to sharpen our Smartsheet agentic workflow. The agents run intake, scheduling and the operational paper trail; the human closes the loop where it counts.
The countdown above just jumped ~60 days — that is why. We would rather ship something real than hit a date with a thin page. Building in public means telling you when the date moves too.
The application portal — three candidate-facing stages plus an agent-API path — is one Cloudflare Worker, one set of static pages, and a few KV + R2 buckets. No app server. No operator standing by during traffic. The form itself does the receiving.
We tested every stage end-to-end today, including the 90 MB video upload path, the magic-link expiry, and the duplicate-submit gate (it returns a clean 410 instead of a duplicate row).
Applications open tomorrow night at 20:00 HKT. We will be quiet on the platform for the first 24 hours and watch what real candidates do with it.
Brand Guide v1.1 ships four format types programmatically — report, deck, memo, letter — from a single template stack. Pandoc + WeasyPrint + a Python-driven slide builder.
Anyone on the fleet can produce a polished client artifact in minutes, not hours, and it always looks like ours.
Stream D added an internship track: two builders, 90 days, Hong Kong + Shenzhen. Recruit, contract, train.
The recruitment build became a sub-program in its own right — pre-90 work to lock terms. The first concrete training track for the agentic-workflow operating model.
A Claude Code instance — Anthropic's Opus 4.7 model running through the Claude Code CLI — joined the fleet on 10 April.
Wrote what we would ship in 90 days as a Gantt: about 65 tasks across four streams and 9 keystone milestones. Stream A is acquisition (website, intake, client portal); B is build (intake-to-workflow, requirement brief, NPI execution, intelligence layer); C is coordination (sheet structure, KPI dashboards, supplier coordination); D is training and adoption (internship, onboarding, supplier training).
The countdown above this card targets the V1 launch milestone in stream A.
A compliance daemon — the relay enforcer — now watches every send across every channel: agent message, email, Smartsheet comment, Telegram, file delivery. Each send must match a pre-logged request.
Stage 1 is detect-only — when a byte goes out without authorization, the daemon flags it within seconds. Stage 2 is wired but not turned on; when armed, it kills the offending session and requires re-authorization.
The harness is the fleet's seatbelt.
Custom plugin tooling shipped that lets every OpenClaw agent post comments, attach files, and update rows on the workspace directly — no human relay.
Smartsheet API call → OpenClaw plugin → executed in seconds. Any agent that needs to log evidence or coordinate now does so on the same surface where its work is tracked.
Each agent now has a structured memory directory under tight rules: how memories are written, the four types (user, feedback, project, reference), when to update vs delete.
The memory governance doctrine sits beside the agents. They use it. They challenge it when it's wrong.
Each agent in the OpenClaw fleet got a mechanical capability profile — what files it can read, which tools it can call, what shell commands it can execute. The restriction lives in OpenClaw config and is enforced at the gateway.
Agents cannot escalate themselves. Privilege creep, automated.
Three more sheets joined the workspace within 48 hours: a daily journal, a master audit log, and a registry that tracks every internal markdown document by lifecycle state.
Smartsheet webhooks were added across the workspace so any change anywhere fires an event back into the OpenClaw gateway. Auditability becomes ambient.
The first internal Smartsheet went live. Every build since — software, doctrine, recruitment, even this build log itself — gets its own row, with a forced PLAN → BUILD → VERIFY shape and evidence attached as markdown.
About 80 builds have followed in the 5 weeks since. The team that produces them is a small fleet of AI agents — a mix of Claude Sonnet and OpenAI models — orchestrated by the OpenClaw gateway.
OpenClaw — the agent fleet's orchestration framework — came alive at 20:41 SGT on 5 March 2026.
Telegram joined the same evening as the founder's mobile channel: pings the fleet from anywhere, fleet pings back when something needs attention. From here on, the team runs from a phone.