Meta Operations Conference

Friday 22 May 2026 · National Press Club, Canberra

All content below is under Chatham House Rules — ideas are shared without attribution to individuals unless their work has been explicitly made public. Attributed sections are marked as such.

Attendees

Twenty seven people attended the conference. The room included software engineers, digital agency founders, cyber/defence officers, data/AI consultants, media business owners, financial advisers, marketing professionals, and a retired engineer who had been coding with AI for three months. A deliberately wide spread of technical depth — from people who had built LLMs from scratch to people who had never used AI.

---

Welcome

Format & ground rules

• Chatham House Rules in effect. Recordings exist but video and audio are to be destroyed; only a summary transcript will be shared.
• A carpark list was maintained for important-but-off-topic threads.
• The facilitator's three goals for the day: (1) explore Agent Driven Hyper Development ("ADHD"), (2) understand what business models will persist, (3) figure out what this group can do together.

Introductions

Brief introductions were given by all attendees. Common threads: people had moved from pure data/analytics into AI; software engineers were using AI agents daily; business owners were just beginning to engage; at least one person had been building LLMs since 2018; one person had only started using AI three months ago and was "absolutely astounded" at what he had achieved.

Architecture & LLMs

Architecture & ontology session

The facilitator opened with an OSI-inspired layering of the AI stack, infrastructure and foundation models at the base, with the opportunity sitting at the top, in the middle layer of orchestration, interfaces, and operational tooling.

What is an LLM?

Two contributors walked the room through this:

• Think of the neural network from the outside in: inputs (words/tokens) → hidden layers → outputs. Hidden layers probabilistically determine whether a given output is more or less likely. Activation functions, beam search, and other techniques tune this.
• An LLM is literally a file of numbers — a large, multidimensional matrix. You can download them from Hugging Face or Ollama. The magic is in the probability engine that uses that matrix to predict the next token.
  • GPT = Generatively Pre-Trained Transformer. Transformers existed from ~2015–2018. The GPT paper (~2020) was praised as research but the model was practically useless. ChatGPT's November 2022 release was the step-change moment, the same underlying technology, but more parameters.
• Emergent behaviours (reasoning, planning, code generation) were not planned, they appeared as parameter counts increased. Nobody fully understands why.
• Two schools of thought on scaling limits: (a) there is a ceiling beyond which more parameters don't help; (b) more parameters always produce more interesting emergent behaviour. The Saudis produced a 1-trillion-parameter model was never released, possibly evidence that size alone is not the answer.

Quantization:

• Base model weights are 32-bit numbers. A 120B-parameter model at 32-bit is ~120 GB to download and run.
• 4-bit quantized versions of the same model are ~16 GB — often produce near-equivalent output quality. Critical for self-hosting.

Product survey (show of hands):

The room had used: Perplexity, Claude, GPT/Codex, Gemini, local models via Ollama/LM Studio, some Microsoft Phi models. Almost nobody had used Kimi 2.6 or DeepSeek v4 — "This is Canberra."

Browser → MCP → CLI → Agent framework:

One contributor walked through the evolution of how we interact with LLMs:

1. Browser (Nov 2023): A simple web server serving a chat interface to an LLM. Two billion users in six weeks. A "nanny layer" (RLHF safety filtering) sits in front of every request. "Obliterated" open-weight models have this safety layer removed.
2. MCP (Model Context Protocol): A small web service that maps natural language requests to tool instructions — allowing LLMs to talk to GitHub, databases, file stores, APIs. Every major SaaS vendor is now publishing MCP endpoints. You can write your own MCP server in one or two prompts to Claude Code.
3. CLI: Developers moved LLM access into the terminal. Same as the browser, just a different surface. Claude Code is a CLI. The CLI is increasingly preferred by agents because it is more efficient.
4. OpenClaw (now superseded by Hermes): An open-source project that someone wrote in a weekend with Claude Code and connected first to WhatsApp. Core concepts: a SOUL.MD file (personality/identity), an AGENTS.MD file (rules/behaviours), and a SESSION CONTEXT (running conversation history). The system injected all three into each LLM call with prompt engineering, then parsed the output. Introduced session management: multiple channels (WhatsApp, Telegram, Discord) each maintaining their own session context. Session compression explained — when context fills up, it gets compressed, which is why the model sometimes "forgets."
5. Hermes (current preferred): More stable than OpenClaw. Learns as it goes, writes its own Python skills, so repeat tasks cost no tokens after the first run. Now the foundation of choice for agentic workflows in the room.
6. Cowork / Perplexity Computer / ChatGPT on-device: Products that give agents access to local machine tools (file system, browser) within security sandboxes.

Architecture Diagram — Morning Session Whiteboard

The whiteboard showed the anatomy of a prompt-chat system:

Left side — interfaces:

• Browser, Desktop App, Terminal, Agents (openclaw, Hermes)
• Conversation Channels: teams, discord, slack, telegram, whatsapp - can be used to talk to your "Agent"
• Agents
  • OpenClaw (open-source), annotated with its three files:
    • SOUL.MD - tells your agent what to be, think personality
    • AGENTS.MD - tells your agent what to do
    • user.md - information about you the human that the agent needs to know.
  • HERMES similar to openclaw
  • Differences
    • openclaw very unstable at the moment with every upgrade introducing breaking changes. Extremely configurable and liked by more technical individuals.
    • Hermes is more stable and new releases don't break existing stuff. More considered and opinionated about functionality. Writes it's own skills based on how you used it...learns over time. Middle - API's

• Each model provider has a base set of APIs that everything connects to.

Right side — model and tools:

• Model Management:
  • loads different models
  • provides the API server
  • adds additional functionality such as co-work, code, memory, and file storage.
• Inference Engine:
  • Actually loads the model into memory
  • Safety layer - stops users asking for knowledge that is dangerous to humanity
  • Executes the transformer layers
  • Generates tokens
  • Handles quantization formats such as GGUF
  • Doesn't provide much in the way of user experience
• LLM - Large Language Model weights - basically a huge multi-dimensional set of numbers (or weights)

---

agentaus.ai

Michael Gately presented agentaus.ai:

• Australian sovereign LLM, all data stays in-country. Purpose-built for data-sensitive customers including Defence and NDIS providers.
• Released May 2026. Scaling to 10,000 users as a first stage (approximately one month behind schedule).
• Pricing: roughly half to one-fifth the per-million-token cost of OpenAI or Anthropic.
• Has standard internet-search tool use; MCP integration coming in the next week or so.
• Three Australian software providers have already requested in-country data residency connections.

On Australia's AI adoption: Australia has adopted Claude faster than any other country as a proportion of population. Suggested reasons: we like building things; technical culture runs deep even outside tech. That said, overall Australian AI adoption (at consumer level) remains low, most people using agentaus.ai are still in "what's on this weekend in Canberra" territory.

On future of software: The transition from apps with AI bolted on to AI-native processes with apps as output is coming in the next 24 months. The key question is not "how do I make this faster" but "how do I restructure my process so my people spend their time thinking, not executing."

On code quality: Six months into an AI-generated codebase, a company had a catastrophic failure they couldn't untangle. AI-generated code works beautifully but is not maintained unless you impose the same quality discipline that existed pre-AI. "Don't be lazy with the excitement of AI. Hold the discipline of code quality, that has existed since the punch-card days."

On high-value vs. low-value code: ~90% of lines in a codebase are low-value (boilerplate, CRUD, plumbing). Less than 10% is the secret sauce. Build the 90% with AI under defined processes. Protect the 10%.

Three-model stack (confirmed by multiple contributors):

• Build: Claude Opus (or similar large model)
• Review: A separate model, often a self-hosted open-weight model (possibly Chinese).
• Test: A third model running tests

This pattern was independently confirmed by at least three contributors from different companies.

On security in government contexts: DeepSeek and other Chinese open-weight models may contain backdoors in generated code, nobody has proven they don't. The ASD publishes a primer on safe AI adoption for development: https://www.cyber.gov.au/business-government/secure-design/artificial-intelligence/engaging-with-artificial-intelligence

On apps going to zero: The cost of software is heading to zero. Bespoke development is back. Multiple people in the room had built their own CRM or Kanban board in the last 12 weeks. The question is not can I build this but do I want to run it. There remains a large cohort (Jim the plumber) who just wants to pay someone else. But for technical SMEs and government agencies, the case for replacing off-the-shelf rent-extracting software with self-hosted open-source is now compelling.

---

JourneyHorizon: ChimeDeck

JourneyHorizon https://www.chimedeck.io/ https://github.com/Chimedeck

Background

JourneyHorizon had been using Trello ($6,500/year) and Discord for eight years. They decided to replace Trello to: (a) save money, (b) prove they could build enterprise software with an agentic DevOps pipeline. Prior to October 2025, this was not possible. The Claude Opus models that landed then were a step change in code generation quality.

The "Wagile" methodology

• Detailed design up-front (Waterfall phase): Matt wrote a detailed business requirements document, every screen in Trello described, every workflow articulated. The more detail, the less the AI can hallucinate.
• Sprint-based execution (Agile phase): Opus 4.7 in high-effort planning mode took that specification and broke it into 172 sprint definitions, one feature per sprint. This took two hours and generated consistent, interdependent sprint files.
• Seeded repo: Before any sprints, the GitHub repo was seeded with a model project, code samples from their best prior work, linting standards, coding standards, CI configuration. The AI was not guessing the preferred code structure; it was given explicit standards.
• Changelog as AI memory: A Changelog folder with timestamped entries (what was updated, what's new, technical debt, what to do next). Instead of the AI reading the entire codebase, it searches the changelog like a knowledge graph, deep-first search from a single entry point.
• Markdown over Word/PDF: Markdown files tokenise smaller than .docx or .pdf. Every spec file is Markdown. This matters at scale.

Model selection by task

Agentic Development Pipeline Architecture

1. Foundation: Seeded Repository

Before any AI runs, a GitHub repo was pre-seeded with 8 years of exemplary JourneyHorizon code, coding standards, linting rules, auth patterns, CI/CD configuration, and framework choices. This gives the AI a "strong opinion" about how the code should look rather than making architectural choices from scratch.

2. Requirements: Detailed BRD

Matt wrote a detailed Business Requirements Document (BRD), screen-by-screen, feature-by-feature. The key principle: the more specific the requirements, the less room for hallucination. Every ambiguity is a decision point the AI will guess at.

3. Sprint Planning: Claude Opus 4.7 (high-effort planning mode)

The full BRD was fed to Opus 4.7 in high-effort planning mode with a loose ordering constraint (infrastructure first, auth second, etc.). Opus generated 172 sprint definitions autonomously, each sprint covering exactly one feature. This took ~2 hours. The consistency between sprints is inherent because one model wrote all of them.

4. Three-Model Execution Stack

Different models for different roles:

All runs go through Microsoft Copilot as the front-end, not for the models themselves, but for IP indemnity. On the Microsoft Business plan, Microsoft indemnifies copyright infringement in generated code. Copilot also has a duplicate-detection filter that cross-checks generated code against public GitHub repos.

5. Changelog as AI Memory (Memory Tracing)

A Markdown changelog file tracks the entire project history: what was updated, what's new, what technical debt exists, what should be done next. This serves as the AI's single entry-point to understand codebase state without ingesting the full codebase into every request. The AI does a keyword search from the changelog entry point and follows a depth-first traversal through related files. Markdown was chosen specifically because it minimises token cost vs. Word/PDF while remaining human-readable.

6. One Feature Per AI Run

A hard constraint: one sprint = one feature per AI invocation (two at absolute maximum). Giving AI multiple features simultaneously causes it to become sloppy because it splits attention across the full token window. The sprint definition files are the "box", precisely specified so the AI can run freely inside them without straying.

7. Playwright Automated Testing (MCP-driven)

After each sprint, Playwright runs a full regression test suite via MCP server. Tests are written in natural language (requirement statements, not Gherkin), the MCP server translates these to browser actions. The test pack is built cumulatively across all sprints. This catches the common problem of AI reporting completion without actually completing work. A human navigator still oversees each sprint run and intervenes when the AI strays (especially for mathematical logic, edge cases, or ambiguous instructions).

8. Human-in-the-Loop: Navigator Role

A dedicated human overseer (Tom, as CTO) reviews each sprint output before merging. After the first full build (~128 sprints, 3 weeks), a PM tested the product on staging and provided UX feedback. Human testers catch things AI can't simulate, unpredictable interaction patterns, small UX irritants, aesthetic judgements.

9. Hosting & Distribution

• Infrastructure: AWS, auto-scaling, ~$500/year
• Installation: A skills .md file in the repo describes setup; agents (Hermes or OpenCore) can read it and self-install a fully working local instance in ~7 minutes
• No embedded AI: ChimeDeck itself has no AI baked in. It exposes an MCP API. External agents (orchestrator, planner, dev, test agents) connect to it and use it as their task management layer, token costs are on the agent side, not the product

10. Results

• 128 sprints completed in 3 weeks (estimated 1 year by traditional team of 10)
• Entire codebase (including infrastructure deployment scripts) open-sourced at github.com/ChimeDeck under MIT 2.0
• Security validated via community pen testing; OWASP testing done internally; deeper pen testing planned
• Commercially hosted at chimedec.io ($49–99/month); on-premise self-install option for data-sensitive orgs

Key rules discovered

1. One feature per AI run. The AI performs worse when asked to complete A, B, C, and D simultaneously. It becomes sloppy. Two features at most if you're being greedy.
2. Detail removes room for hallucination. The more ambiguous the requirement, the more the AI can hallucinate into the gaps. Treat specifications like a black box, specify every feature, and the AI stays in the box.
3. Human-in-the-loop is non-negotiable. The AI passes every functional test but cannot simulate human behaviour. Humans do "stupid shit", they click the wrong button, multitask, have bad days, approach things in unpredictable sequences. UX problems don't appear in automated testing; they appear when a real person uses the product. After the first version passed all tests but the PM refused to use it ("there's no way I'm using this until you fix these 20 things"), they added human testing after every sprint.
4. Oversight prevents runaway costs. Leaving AI running unattended is like "firing a spaceship without being in the control room." One contributor accidentally left their AI overnight and spent $5,000 in tokens. You need a navigator.
5. Playwright for testing. Every sprint ends with the test suite run against the full regression pack. Functionally this is what every project says it will do and never does, because there is no funding to maintain the pack. AI removes that constraint.

Results

• 128 sprints delivered in 3 weeks by one person
• Equivalent would have been: 1 year traditional, 3 months with 5 people six months ago, 1 month with 5 people one month ago
• First version: functionally complete, all tests pass, but PM refused to use it because the UI had dozens of small alignment and behaviour issues
• Subsequent sprints: human feedback loop added; quality converged to "the team read it and said it's better than what we could ever write"

IP and copyright

• JourneyHorizon uses Microsoft Copilot (not Claude Code directly) for production client work
• Microsoft indemnifies Copilot business-plan subscribers against copyright infringement in generated code — unique in the market; Anthropic and OpenAI do not
• GitHub has a filter that cross-checks generated code against public repos and blocks generation if it finds a match
• The ChimeDeck repo is open-source (MIT 2.0). The whole codebase and process; spec files, sprint definitions, test suite, is at github.com/Chimedeck

Security and open source

• Published the entire ChimeDeck codebase publicly as a security test. Vulnerabilities were found; the quality of contributions proved the software was sophisticated enough to require real effort to break.
• Ongoing debate in the room: open source vs. closed source security. One view: open source is more secure because it can be comprehensively scanned and patched. Closed source just makes attackers work harder for the same result. Counter: projects like cal.com have recently gone closed-source because people are cloning repos and asking Claude to rewrite them in Rust, making copyright law irrelevant.
• Supply chain / dependency injection attacks are live: ~3,000 open-source repos compromised through account takeover; malicious code injected into widely-used packages (pip package for Azure polling APIs was one recent example).

ChimeDeck as a product

• Self-hostable Trello replacement, on-premises option for organisations that won't put data in the cloud
• $500/year hosting vs $6,500/year Trello
• Commercial hosted version: chimedec.io at $49/month
• Migration from Trello: most data migrates via API; attachments require a workaround (agent clicks the download button on every card)
• Future: the product is not "AI-embedded", you bring your own agent (Hermes, OpenClaw) and connect it via MCP. The AI component is agent-driven, not baked in.

---

JourneyHorizon: AI Marketing Team

JourneyHorizon (digital agency, 60 staff, Vietnam-based) https://mkt-agent-presentation.milotiger.workers.dev/#0

Context

JourneyHorizon has a traditional small agency inside the business: one marketing lead, a graphic designer, a video editor, a Webflow developer, two content editors, and two SEO analysts. Eight people. Currently servicing five clients.

Goal: each of those eight people should be able to manage 10–20 clients using an AI team. Then the AI team definition becomes a product that can be handed to any business, "you no longer need to ring us as an agency."

Architecture

• Runtime: Hermes (from Nowse Research, four-person team in China)
• Primary model: Claude Opus 4.7 for research and planning; lighter models for execution
• Communication: Discord channels give each agent context; humans interact with agents just like real teammates
• Tasking: ChimeDeck (their own Trello replacement)
• Knowledge base: Outline Wiki (open source, MCP API endpoint)
• Output channels: Webflow, Shopify, Facebook, Instagram, LinkedIn, TikTok
• MCP layers: SEMrush, GitHub, Playwright, Google Docs

The marketing team has domain-specific agents (SEO Expert, Content Creator, PM) and publishes to external channels (Webflow, Shopify, Facebook, Instagram, LinkedIn) via SEMrush MCP and Google Docs. These are the outputs of the system once the dev pipeline delivered ChimeDeck.

The marketing agent team runs specialised agents in addition to the Chimedeck solution.

• Planner: reads campaign briefs, proposes strategy, breaks into tasks, creates ChimeDeck boards with deadlines and dependencies
• SEO Expert: runs weekly SEMrush audits, identifies keyword gaps vs. competitors, creates GitHub PRs for auto-fixable issues
• Content Creator: writes blog posts, social copy, email snippets; human reviews before publish
• Executor: publishes to channels via Playwright (real browser, not API — avoids bot detection)
• PM agent: sits over the top, manages the whole flow

Key metrics

• 55 hours/week of manual marketing time → ~2 hours of human time with the AI team
• 5 clients with 8 people → target: 60 clients with 8 people
• SEO content cycle: 180 hours/month → 3 hours/month; 60 articles/month output

How Hermes learns

• Every job done, every piece of human feedback ("that wasn't great," "that was perfect"), Hermes determines whether to update its skill files or memory.
• Once Hermes has done something, it writes a Python script for that task, subsequent runs use the script, not tokens.
• Skill changes pushed to the Outline Wiki for human transparency and tweaking.
• Unsolved: how to export the learned skills from one Hermes instance and package them for another. Currently the knowledge is in skills files and memory files inside the directory, needs a packaging process.

SEO content generation (brief on process)

• Identify a target keyword
• Opus 4.7 researches top-five-ranked articles for that keyword
• Summarise the key points across those five
• Feed summary + brand context + keyword to content creator agent
• Strict prompt engineering honed over six months
• Result goes to human for review, they now find it better than what they could write themselves
• Not writing for humans to read; writing for Google's indexing bot. The standard is "good enough for SEMrush and Google to index it correctly."

B2B agent commerce (Agent Market)

Matt's longer-term thesis: all B2B commerce will become agentic.

Current state: vendors like Shopify and WooCommerce have added MCP endpoints so agents can interact natively as sellers. As a buyer, agents can go find services for you.

What is missing: consistent B2B rails for agent-to-agent transactions. His example: an agent at a mechanics workshop wants to book a service that requires 19 specific parts. Six of them are in stock. The agent needs to raise purchase orders for the other 13, and it should be able to:

• Hit an agent marketplace
• Search by IPB/part number
• Negotiate purchase orders with supplier agents
• Process invoices and payments between agents
• Fall back to alternate-part catalogues if the exact part isn't available
• Fall back to registered machinists if a custom part is needed

For this to work, agents need: a registered identity (DID), a crypto wallet, governance rails from their human (max spend per transaction, negotiating authority, budget), and escrow rails (Bitcoin/stablecoins/Polygon are ready for this).

JourneyHorizon has a detailed spec and architecture for Agent Market and is currently fundraising (~70–80 LinkedIn cold outreaches via Hermes using Sales Navigator; ~10 responses, a few meetings pending).

On brand value in agentic commerce

An important observation from building this: brand value drops significantly in an AI-first commerce world. Agents don't care about brand, they evaluate on information. The glossy website, the Greg Norman logo on the golf clubs, irrelevant. What matters is accurate, structured information and third-party reviews.

This inverts marketing: you are no longer marketing to humans, you are marketing to agents. The content that wins is high-quality structured information, not visual identity. This may make the commercial web significantly less visual over time.

---

Federal Government Opportunities & Future Scenarios

Federal government as a market

The opportunity in federal government:

• Government ICT operating models have not changed in 30 years. Divisions still siloed into infrastructure, OS, and apps. This is both the challenge and the opportunity.
• Migration and modernisation: A customer has been nine months into moving from GitLab/Bitbucket/Jenkins to GitHub. Earmarked for 12 months. The same work could be done in six weeks by one person, effectively for free (GitHub pulls the cost). But there is no pathway through the agency's process.
• The big four are not doing this. They are bidding 12-month, 20-person engagements that will probably not deliver. The opportunity is for smaller, AI-enabled firms to walk in, have the right conversation with SES-level leaders, and demonstrate six-week delivery.
• Data management and governance has been neglected for 20 years across government. Data platforms are 20+ years old. The AI-enabled firm that gets in and starts cleaning, governing, and productising that data will have a moat like nobody else. As an example: Defence's clearance system re-engineering introduced a data model change (clearance-based to person-based), and the data migration was so poorly managed that individuals ended up with seven parent records. Nobody did the data.
• Above-the-line advisory: The days of the big four and McKinsey delivering above-the-line services are numbered. Getting in at secretary level to talk about what departments should look like in 20–30 years is a massive open opportunity.
• Grant systems: Two grants systems in this town, both outdated. Current government thinking is "SAP or Dynamics." An AI-native grants management approach, potentially delivered as an outsourced service, is wide open.
• Monolith decomposition: Service Australia, ATO, Home Affairs all have 30-year-old monolithic platforms that have had three or four failed decommission attempts. The approach of feeding the source code to AI, generating a specification, then chipping features off one at a time as standalone next-gen capabilities is a genuine strategy nobody is currently executing.

Insight from the floor: If you fed the entire source code of ICSE or the visa processing system to an AI simultaneously, it would provide insights the public servants probably don't want to hear, revealing just how much money is being wasted.

LLM Futures

• Inbuilt AI features in SaaS platforms (Copilot in Dynamics, Gemini in Google Workspace, AI in Salesforce) will become ubiquitous. Why build your own capability when Salesforce delivers it integrated?
• The secret sauce is your own data, applying your proprietary data to these models is where the differentiator lives.
• LLMs and tokens will become a commodity over the next 24 months. The excitement about new model releases will fade. What matters is applying the capability to your customer transaction and interaction data.
• Government data holdings are so rich they don't even know what they have. Productising and releasing that data (open source where appropriate) and using it to drive fine-grained policy decisions is an enormous opportunity nobody is pursuing.
• The younger generation coming into the public service will drive change. "You mean I don't have Copilot?" will be a genuine blocker.

---

Coax: Omni-channel Inbox for SMBs

https://coax.com.au/

What it is

Coax is an omni-channel inbox and AI platform for small-to-medium businesses. It consolidates all customer communication channels, phone (VoIP), SMS, WhatsApp, Instagram DMs, Facebook Messenger, web chat widget, into a single inbox, vectorises every interaction, and uses AI to respond with full context.

Why it was built

Coax came from performance digital marketing and was frustrated by the constant question: "Did you contact that lead?" Answer always: "Of course, straight away." Reality: they hadn't. Businesses had phone calls in one system, web leads in another, SMS in a third, with no context threading between them.

How it works

• Every call is transcribed (using DeepGram; was previously a different provider with poor transcription quality) and summarised by AI
• All conversations — regardless of channel — are vectorised against the contact
• When someone contacts the business again, the AI has full context regardless of channel
• AI handles simple queries end-to-end (e.g., "where is my order?" → AI fetches Shopify order → finds tracking ID → returns ETA — one interaction that previously took a human 1–2 minutes, replicated 30–50 times a day)
• For complex queries, AI triages (using GPT 5.5), identifies the correct flow/framework, then fetches the relevant tools
• E-commerce example: AI creates a draft Shopify order pre-populated with all requested products → sends checkout link → customer enters card details → done

Tech stack

• Transcription: DeepGram (high-accuracy; context-aware — knows what business, what products)
• Triage: GPT 5.5
• Development: Opus 4.7 to build; Codex for review (same three-model pattern as others)
• Infrastructure: Postgres/Neon database (rebuilt six times); Sentry for session replay and error logging
• VoIP: hybrid Twilio/Wildjar (two years debugging Android diversity and carrier limitations, "the most painful thing I've ever built")

On small business AI adoption

"When I give them a tool that says: AI can answer 'where is my order?' and the AI will go fetch the tracking ID, identify it's at Melbourne Airport, they say — don't do that. That's scary."

Small businesses are petrified of AI acting autonomously. Coax built a "draft mode" as a stepping stone — AI drafts responses, human reviews and sends. As they see AI getting smarter (it's just improving context), they enable more.

Voice is the hardest step: "Once the words are coming out, you can't take them back." Businesses want granular control over when the AI speaks, what it can and cannot say, when it stops.

AI persona builder: configure when the AI engages, what it should and should not do ("don't discuss competitor pricing"), what tools it can call, and whether it responds autonomously or in draft mode.

On analytics

Coax spent nine months building analytics dashboards. Never launched them — everyone wanted something different. Solution: expose the API and let customers use Claude to build their own dashboards. Multiple customers are now doing exactly this — one built a ticket open/close counter inside a Chrome extension using Claude Code in an afternoon. The platform becomes stickier because customers own their own view.

On token cost management

Token costs are currently unmanaged, tracked per account but not yet capped or rate-limited. Eight weeks into enabling AI for all accounts, still figuring out the commercial model. Acknowledged that token costs will drop as capability improves (same capability, lower cost). Managing the transition between current subsidised pricing and eventual profitability is the live challenge for every company in the room.

---

Open discussion — winners, losers, and the future

This became a wide-ranging, contentious discussion. Key threads:

The individual empowerment thesis:

• One contributor, said discovering Claude Code three months ago had been the most significant professional shift of his life. He had built applications he never thought possible.
• AI empowers curious individuals and entrepreneurs to a capability level previously only available to well-funded startups or established businesses. It is a force multiplier.
• Counter: if everyone builds another Shopify or Zango, where is the value? Competition collapses margins to zero.
• Resolution: critical thinking remains the scarce resource. AI offloads the base-load execution, freeing people to think. Those who use that time to think will win. Those who use AI to do more of the same, faster, will be trapped.

Critical thinking — winner or loser?

• AI atrophies critical thinking for those who let it do their thinking.
• AI enables critical thinking for those who use it to clear their execution backlog.
• Military context: junior officers using Copilot to generate decisions that their training should have produced are losing the very capability they are meant to develop.

US vs China:

• The US approach: closed-source, massive compute, high cost.
• The Chinese approach: open-weight, efficiency-driven (no access to the same compute, so must squeeze more from less). The DeepSeek release earlier this year caused the entire AI market to panic.
• The crusades analogy: Richard the Lionheart's two-handed broadsword vs Saladin's scimitar, completely different philosophy about force application, equally dangerous.
• Practical implication: Chinese models are ridiculously capable and cheap. Defence/intel can't use them. Everyone else should evaluate them seriously.

Infrastructure timing debate:

• Is this an electricity moment (right timing, infrastructure players make fortunes) or an internet/fiber moment (directionally correct, but too early, everyone who built fiber went bankrupt, and the golden assets were picked up for cents on the dollar 10–15 years later)?
• Current AI economics: subscribers pay ~$200/month, but the actual compute cost to serve them is $3,000–$5,000/month. The companies are burning cash to acquire market share. Where does the revenue come from when those subsidies end?
• Is AI like the airline industry, everyone uses it, everyone depends on it, but nobody makes money? The infrastructure spend (GPUs burn out and need replacement every three years) is enormous. Who pays for it when AI-enabled unemployment is reducing the tax base?
• One contributor believed ASICs (e.g., Positron) are 100x more efficient for inference workloads, and that hardware shaped by software — chips optimised for specific model mathematics — will change the equation.

Energy:

• AI performance has been degrading for five years due to power constraints.
• Infrastructure: GPU hardware burns out every three years under continuous load. Trump's data centre spending is creating short-term supply, but the next cycle will need another trillion.
• Nuclear is the only viable path. Nobody likes it, but that is the reality.
• One contributor pointed out that there are two fusion reactors currently running (Western and Eastern). One already produces more energy than it consumes. Microsoft has signed a data arrangement with a fusion reactor in Washington state and is building an AI data centre to draw power from it.
• Fusion creates effectively infinite free energy. If that lands, the entire supply chain becomes free.

ASI and the Skynet/Utopia spectrum:

• The AlphaGo reference: Demis Hassabis built the system that beat the world's Go masters, and his view is that the correct response to what is coming is "get a comfortable chair and a large bucket of popcorn."
• One contributor: within 8–10 months of an AGI/ASI, all unsolved mathematics will be solved. Erdős problems are being solved at pace. Mathematics solved → physics solved → biochemistry solved → everything else solved. The path from there to free energy and solved disease is not implausible.
• Counter: we are also assembling all the pieces of autonomous warfare simultaneously (drones, robotics, AI targeting). The line between utopia and Skynet is exactly ASI alignment. Not enough people are thinking about that problem.
• Where did the room land: firmly in neither camp. Both scenarios are live. Navigating the transition is the work.

Agentifying organisations:

• One contributor's framing: there have been three major change waves worth building businesses around, client/server, cloud migration, and now agentification. The cloud migration required skilled infrastructure engineers to actually do the work. This transition can be done by anyone entrepreneurial enough to try. That changes the market dynamics significantly.
• The business is not just "helping organisations move to AI." It is a continuous evolution, organisations need to keep evolving once agentified, not just transform once.

Winners

• Individual productivity
• Creativity and critical thinking (for those who use AI to enable it, not replace it)
• Start-ups and smaller teams, AI makes them cheaper and more competitive
• Human-tailored UX built on wholesale data and services
• AI-enabled people (the augmented, not the replaced)
• Inference infrastructure (the compute layer)
• Energy / data centres / chips / ASICs
• If the optimistic scenario holds: all of humanity — solved problems, free energy
• Businesses with genuine value-add in the interaction layer
• Creatives

Losers

• People doing too many things, spread too thin to adapt
• Laggards, will be left behind
• Steady-state, compliance-oriented operators who can't adapt
• Creativity and critical thinking if you are lazy and over rely on AI

---

Closing & Next Steps

The facilitator closed the day by offering to:

1. Turn the recordings into a summary transcript (this document).
2. Set up a collaboration group.

The room broadly agreed to reconvene in three months — with the explicit acknowledgement that in three months the landscape will look completely different again. Someone suggested the meeting might by then consist of everyone sitting on a beach somewhere, with AI agents in the room instead.