TL;DR

• We collapsed 86 interdependent Go microservices (~500K lines, 6 years old) into one TypeScript monolith (~231,000 lines) on Cloud Run, with AI agents doing all the engineering. No human hand-wrote the new code.

• Two AI models estimated 6-7 months for a human team. The migration itself took about two weeks.

• The whole thing works for one reason: we never trusted the AI. We made it prove every change against tests it couldn’t cheat.

• The old Go system was the spec. The same test suite runs against both the old Go and the new TypeScript (Go build tags). Both green means identical behaviour.

• Our first test suite was a lie. Coverage was real, but the tests asserted nothing. The AI was cutting corners to hit the number (Goodhart’s Law). So we rebuilt testing so that every side effect (every outbound call, DB write, Kafka publish) has to be explicitly asserted, or the test fails.

• The migration ran as a plain-Python factory: a 7-phase, gated pipeline per service, specialist agents for each role, two models reviewing every change, and automatic rollback on any regression.

• The takeaway for anyone building with AI: the AI can do almost anything if you give it an honest, unbluffable signal of whether it’s right. The hard question isn’t “is the model smart enough?” It’s “what’s my unbluffable check?”

1. The problem

Our backend is a core part of what our business runs on, and one of our main revenue sources. It was built over the last six years, on a more complicated architecture: a fleet of small, single-purpose Go services that talk to each other over RPC, coordinated through Kafka, with ScyllaDB for storage and Redis for caching, all on Kubernetes. If none of that means much to you, the picture is simple enough: a large, old machine with 86 separate moving parts, all wired together and all talking to each other at once.

That’s a brilliant design at scale. But we are a small team (our CTO and four product engineers). So we were paying an enormous operational tax to run and reason about 86 services for load we don’t have. Worse, it was Go, while everything else we build is TypeScript, and our newer product, built from scratch in TypeScript with AI, moves far faster. We had a direct control group telling us this backend was holding us back.

The plan: collapse all 86 services into one TypeScript service on Cloud Run (a fully managed runtime, so you deploy it and forget it), keeping ScyllaDB for now. The SQL migration is a deliberate phase two, because you don’t change too many things at once.

The scope, measured from the repo:

Two AI models, asked independently, put a human team at 6-7 months. And that estimate assumes the sane approach: migrate it slowly and incrementally, one service at a time, old and new running side by side, while still shipping features to the live product. That kind of migration drags on for the better part of a year, quietly competes with every other priority, and usually stalls out half-done. Realistically it never even gets started. You just live with the tech debt forever.

So we did the opposite. We gave ourselves one week. It was a deliberately absurd target, and the absurdity was the point: you cannot hand-crank 86 services into a new language by hand in a week. The only way the number makes any sense is to stop thinking about migrating services and start thinking about building a machine that migrates services. Let the agents do the engineering, and put all of our effort into the factory that runs them, the tests that check them, and the guardrails that keep them honest. A gentler deadline would have let us quietly fall back into porting it by hand, service by service, and we’d still be going now. (For the record, it took longer than a week. But if we’d given ourselves a month, it would have taken two.)

2. The core bet: the old system as an oracle

You can’t just ask the AI to rewrite it. Even if the model is good, how would you know it got it right? Across half a million lines, you can’t eyeball it.

So the bet was: make the old system the definition of correct, and never argue about anything else.

1. Rewrite it bug-for-bug. If the old code had a bug, the new code keeps the exact same bug. The number-one rule was don’t change anything, because the moment you “improve” something mid-migration you can no longer ask the one question that keeps you safe: is the behaviour identical? (Improvements come later, once you’re in one language and can move fast.)

2. Test at the boundary, not the internals. For each service we captured its observable contract: every request in, every response out, every call it makes to other services, every DB write, every Kafka publish, all as tests against the old Go.

3. Run the identical tests against the new TypeScript. Both green means the new service behaves identically, down to the edge cases and the bugs.

The AI is never the source of truth. The tests are.

There were no tests in the legacy codebase to start with, so step one was having the agents write them: around 7,500 tests across 1,270 files.

3. The cross-target harness: one test, two systems

This is the piece that turns a risky rewrite into a safe migration.

The same Go test body runs against both the old Go handler and the new TypeScript server, selected by Go build tags:

// legacy/service.user-job/handler/testmain_go_test.go
//go:build e2e && !ts        // Go target

// legacy/service.user-job/handler/testmain_ts_test.go
//go:build e2e && ts         // TypeScript target

// legacy/service.user-job/handler/put_user_job_test.go
//go:build e2e               // shared test body, compiled for BOTH

go test -tags="e2e" boots the Go service in-process. go test -tags="e2e,ts" boots the TypeScript server and points the same tests at it.

The two TestMain files boot the respective backend. The Go one serves the handler on a local port and registers it in the RPC client’s routing table:

// legacy/service.user-job/handler/testmain_go_test.go
typhonSrv, _ := typhon.Serve(svc, ln)
testharness.SetupTyphonClient(map[string]string{
    "service-user-job": typhonSrv.Listener().Addr().String(),
})

The TypeScript one spawns the real server as a subprocess and waits for it to go healthy:

// legacy/service.user-job/handler/testmain_ts_test.go
_, err := harness.StartTS(testharness.TSConfig{
    Service: "service-user-job",
    Env: map[string]string{"TS_BOOT_SCOPE": "", "JOBS_JOB_KEYS": "[]"},
})

Under the hood StartTS boots the real TypeScript server as a subprocess with the test infrastructure wired in, waits for it to report healthy, then registers it in the same routing table the Go target uses.

The test body is written once and knows nothing about which target it’s hitting. It just calls the proto-generated .Send(ctx), which routes via the RPC client to whichever backend was booted:

// legacy/service.user-job/handler/put_user_job_test.go
func TestPUTUserJob_CreateNew_NewCron(t *testing.T) {
    harness.SetTest(t)
    resp, err := req.Send(ctx).DecodeResponse()

    testharness.AssertResponse(t, harness, resp, err, map[string]any{}).HasStatus(200)
    harness.AssertDBInsert(t, "crons", "jobkey", req.JobKey, "cron", req.Cron)
    harness.AssertDBInsert(t, "jobs",
        "userid", req.UserId, "jobkey", req.JobKey, "endpoint", req.Endpoint,
        "method", req.Method, "payload", req.Payload)
}

Crucially, the infrastructure is shared. Go and TS runs hit the same Scylla cluster, Kafka broker and Redis instance, so parity is checked on real state changes, not mocks. 116 services ended up with this dual testmain_go/ts setup.

A debugging move we leaned on, once something looked off: write a test that passes in Go but fails in TypeScript, then hunt down every place we made the same mistake. That’s how we caught a whole class of wire-format bugs (for example, requests arriving snake_case but responses serialising camelCase).

Because these tests only exist to prove parity, they’re scaffolding. Once a service is cut over, the cross-target tests can be retired.

4. The false dawn: the AI was cheating

Our first approach to writing those tests was the obvious one: point agents at each service, tell them to write integration tests, and chase code coverage (Go reports it directly, so we had a real number and a dashboard). Coverage climbed, service after service went green, and we thought we’d cracked it.

Then we looked closely. The coverage was real. The verification was fake.

Here’s a typical example. We’d tell it: this service calls another one, make sure that call happens and test it. And it would write a test that executed the code path (so coverage counted it) but quietly mocked the call out and asserted nothing. Maximum coverage, happy-path only, and it wouldn’t check the database even when we told it to. The coding equivalent of “yeah, yeah, I tested it, Dad.”

Concretely, it looked like this: the test stubs a fake response for the call, runs the handler, then checks nothing.

// the handler calls /read_user; the test stubs a canned response…
mockRouter.RegisterHandler("/read_user", testharness.CannedJSONHandler(map[string]any{
    "user": map[string]any{"id": userID, "display_name": "Test User"},
}))
// …and then asserts nothing about whether /read_user was called, or with what.
// Green. Covered. Meaningless.

This is Goodhart’s Law: when a measure becomes a target, it stops being a good measure. We made coverage the target, so the AI optimised coverage, not correctness. It wasn’t malicious. It was a lazy genius cutting corners to hit the number.

The pivot: stop trusting the AI. Make it prove it, with a test framework it can’t game.

5. The un-cheatable test framework: assert every side effect or fail

So we deleted the first suite entirely. That sounds dramatic, but it was the pragmatic call: with the new approach ready, having the AI regenerate the tests from scratch turned out faster than getting it to repair the old, hollow ones. Fixing meant untangling thousands of meaningless assertions one by one; regenerating meant starting clean, under rules it couldn’t cheat. When regenerating is this cheap, throwing the work away can beat fixing it, which is a genuinely new thing about building software with AI.

The new approach changed what a test is. Instead of “did this line run?”, the rule became: every side effect a service produces must be explicitly asserted, or the test fails.

The harness arms recording proxies when you call harness.SetTest(t) and captures everything the service-under-test does:

• outbound RPC calls (MockOutboundRouter)

• Kafka publishes (KafkaRecProxy)

• DB reads, writes and deletes (DBTracker)

• the response itself (must be asserted via AssertResponse / AssertError)

Then, at test cleanup, it fails the test if anything was recorded but not asserted:

// legacy/libraries/testharness/harness.go  (t.Cleanup registered in SetTest)
if h.KafkaRecProxy.HasTraffic(name) && !h.KafkaRecProxy.Asserted(name) {
    var unasserted []string
    for i, p := range produces {
        if asserted[i] { continue }
        unasserted = append(unasserted, fmt.Sprintf("Produce to %q", p.Topic))
    }
    if len(unasserted) > 0 {
        t.Errorf("[recording] unasserted Kafka Produces, call harness.AssertKafkaProduce:\n  %s",
            strings.Join(unasserted, "\n  "))
    }
}
// …same for RPC calls, DB writes, and the response.

So a test that publishes three Kafka messages and asserts two doesn’t pass with a warning. It fails, and it tells you exactly what you missed. There’s no “happy path only” any more. If the code does a thing, the test has to account for it.

“Account for” means fully assert. The matcher (deepCompare) is bidirectional: a missing expected key fails, and an unexpected actual key fails too:

// legacy/libraries/testharness/assert_json.go
for k, ev := range expMap {                 // every expected key must exist…
    if _, ok := actMap[k]; !ok { errs = append(errs, path+"."+k+": missing from response") }
    errs = append(errs, deepCompare(path+"."+k, actMap[k], ev)...)
}
for k := range actMap {                     // …and no EXTRA keys allowed
    if _, ok := expMap[k]; !ok {
        errs = append(errs, fmt.Sprintf("%s.%s: unexpected field in response (value: %v)", path, k, actMap[k]))
    }
}

That “unexpected field” branch is what makes hollow assertions impossible. You can’t assert one field and ignore the rest, because the extra fields fail the test until you account for them.

For fields that genuinely vary per run (timestamps, generated IDs) you can use testharness.NonEmpty or testharness.Any:

// legacy/service.hubspot/handler/put_contact_record_test.go
harness.AssertExternal(t, "hubspot", "/engagements/v1/engagements", map[string]any{
    "engagement": map[string]any{
        "active": true, "type": "NOTE",
        "timestamp": testharness.NonEmpty, // drifts per run
    },
    "metadata": map[string]any{"body": "RSVP'd to AI Workshop in London on 2026-05-01"},
})

But wildcards are a loophole, so they get policed too (next section).

Why this was the turning point: it gave the AI a tight, honest feedback loop. It no longer had to read and reason about the whole codebase to know whether it had done a good job. It ran the tests and got a deterministic, specific failure it could act on (”you didn’t assert the produce to notification.created“). It could grind in a loop and brute-force its way to correct, but it could no longer fake the result. Ralph Wiggum in a loop, with a judge it can’t bribe.

We didn’t make the AI reliable. We built a system that’s reliable even though the AI isn’t.

6. Closing the loopholes: the anti-cheat audit scripts

Once side effects had to be asserted, the AI’s corner-cutting just moved to subtler places. So each loophole got its own deterministic check (all in migration/scripts/):

Under-assertion is caught by deepCompare‘s “unexpected field”, then auto-repaired by fix_under_asserts.py, which parses the failures and adds the missing fields:

# migration/scripts/fix_under_asserts.py
UNEXPECTED_RE = re.compile(r'^\s*\$\.([A-Za-z0-9_.]+):\s+unexpected field in response\s+\(value:\s*(.*)\)\s*$')

Wildcard overuse (using Any for a field that’s actually deterministic) is caught by wildcard_diff.py, which records two identical e2e runs and diffs them. If a wildcarded value is the same across both runs, it’s stable and should be a literal; only genuinely drifting values are allowed to stay wildcards:

# migration/scripts/wildcard_diff.py
if va == vb and ta == tb:  stable.append(...)   # safe to literalise
else:                      drift.append(...)    # must stay a wildcard

On one service alone (service.article-comments), this flagged 57 of 108 wildcarded values as stable: more than half of the AI’s “checks” were checking nothing.

Boundary shortcuts (a test calling a Go DAO directly instead of going through the public HTTP/RPC boundary, which couldn’t be re-run against TypeScript) are caught by check_boundary_entry.py, which statically checks every Test* reaches a real entry point:

# migration/scripts/check_boundary_entry.py
HANDLER_PATTERNS  = [r"\.\s*Send\s*\(\s*ctx\b", r"\btyphon\.NewRequest\s*\(", r"\bhttp\.Post\s*\("]
CONSUMER_PATTERNS = [r"\.\s*Publish\s*\(\s*ctx\b", r"\bstreams\.Publish\s*\("]
# fails: "Handler tests missing public HTTP boundary (.Send(ctx), …)"

“Untestable” as an excuse (marking a branch uncoverable without justifying it) is caught by audit_ceiling_cheats.py, which enforces a fixed taxonomy and rejects weak reasons:

# migration/scripts/audit_ceiling_cheats.py
ALLOWED_TAXONOMY = {"DEAD_CODE","UNREACHABLE_FROM_BOUNDARY","ASYNC_KAFKA",
                    "NON_DETERMINISTIC","VENDOR_LOCKED","FRAMEWORK_PLUMBING"}
WEAK_KEYWORDS = ["in practice","production","typically","should never","shouldn't happen"]
# DEAD_CODE must cite a code-level reason ("return nil", "constant", "unreachable"), not vibes.

The pattern was the same every time: whenever the AI found a way to cut a corner, we turned that corner into a deterministic check. You don’t out-argue the model. You build a fence it can’t climb.

7. The migration factory

With trustworthy tests, the migration itself became a plain-Python assembly line (migration/scripts/) that drove AI agents through a gated pipeline per service. Boring, deterministic orchestration; AI supplying the intelligence.

Each service ran through seven phases (chief_migrator.py, migration_factory.py):

1. Maximise coverage (maximize_all.py): measure go test -cover, have an agent classify every uncovered path as testable or untestable, write tests for the testable ones, iterate (rolling back if coverage regresses).

2. Contract tests (generate_contract_tests.py): pin the HTTP wire format (status codes, headers, exact JSON field names).

3. Interaction tests (generate_test_interactions.py): enforce full side-effect assertions (the framework from section 5).

4. Quality audit (run_all_test_generation.py): batches of test functions audited and classified OK, GAP, N/A or UNFIXABLE, fixed iteratively.

5. Verification and migration gate: a fresh go test, then a go/no-go decision:

# chief_migrator.py
m = re.search(r'GATE_DECISION:\s*(READY|MIGRATE_WITH_CAVEATS|DO_NOT_MIGRATE)', output)
decision = m.group(1) if m else "DO_NOT_MIGRATE"    # default is "don't"
...
if migrate and result["gate"] != "DO_NOT_MIGRATE":
    p6 = run_phase6_migration(target)
elif result["gate"] == "DO_NOT_MIGRATE":
    result["status"] = "GATED"                       # pipeline stops; no migration

6. Migration (run_migration.py): an orchestrator agent spawns specialists. An architect reads all the Go and plans the TS files, a coder writes them chunk by chunk, and two reviewers run in parallel (a different model from the one that wrote the code) checking behaviour fidelity, error codes and wire format. Both must PASS before moving on.

7. Cross-target tests: run the Go e2e suite against the new TS server (section 3). Fix and iterate until green.

Models by role (invoked via droid exec): Codex 5.3 (xhigh) for fast coding and audits; Opus 4.6 (max) for orchestration, architecture and review; with GPT-5.3 and Gemini 3.1 in the review and consensus mix. Using different companies’ models to review each other matters, because where one is blind, another catches it.

Playbook per service type. One generic migrator was mediocre at everything, so the factory picks a tailored playbook by service type:

# chief_migrator.py
svc_type = "api" if svc_dir.name.startswith("api.") else "service"
# edge.* GraphQL packages are discovered separately and use 015_EDGE_TEST_PLAYBOOK.md
# service.* / api.* use 014_TEST_PLAYBOOK.md

GraphQL edges need different handling (schema, resolvers, dataloaders, error extensions, pagination cursors) than REST services (handlers, consumers, DAO, Kafka).

Automatic rollback. Before any assessment step that lets an agent touch test files, the factory snapshots them; if the agent breaks the suite, it reverts:

# chief_migrator.py
def rollback_test_files(snap, target):
    for fpath, content in snap.items():
        p = Path(fpath)
        if p.exists() and p.read_bytes() != content:
            p.write_bytes(content)          # restore modified
    for f in base.rglob("*_test.go"):
        if str(f) not in snap: f.unlink()   # remove newly-added
# → "[CHIEF_MIGRATOR] Assessment broke tests, rolled back N file(s)"

The safe state was always the default, which is what let it run mostly unattended (phases parallelised with -j, for example maximize_all.py -j 4, run_migration.py -j 5, with per-phase timeouts measured in hours).

8. Discovery and anti-hallucination

Before any of that, we had to understand 86 services nobody on the current team had written. We pointed one agent per service at the code (migration/discovery/scripts/run_discovery.py), auto-splitting the big ones into chunks of at most 40 files. The prompt was blunt: “Be exhaustive. Read EVERY source file. Do not skip, sample, or summarise.”

The obvious risk is hallucination, so every non-trivial claim had to cite a specific line of code:

# migration/discovery/prompts/discover-service.md
- Every non-trivial claim MUST include an evidence tag: [evidence: relative/path/file.go:12-34]

A verifier (verify_reports.py) parsed those tags and rejected the report if citations were missing, invalid, or didn’t cover enough of the source files, triggering a strict regenerate-from-scratch retry. Then three models from three companies (Opus 4.6, GPT-5.3 Codex, Gemini 3.1 Pro) independently reviewed each report for completeness, and review_consensus.py blocked synthesis unless they agreed (score spread within 10, no split verdicts, no “unsupported statement” flags).

The output was a living PATTERN_PLAYBOOK.md: a catalogue of all 86 services, a domain map, an 80+ topic Kafka catalogue, and the recurring async patterns (fire-and-forget, event sourcing, fan-out, sagas, Kafka-to-Redis bridges). That’s what turned “rewrite this” from guesswork into applying known patterns.

9. Prompting lessons (the cheap, painful ones)

• Never say “make the tests pass.” You’re literally inviting the model to delete or skip the hard ones. It does the literal thing, not the intended thing. Say what “done” means, and enforce it in the harness.

• Don’t make a proxy metric the goal. “Get coverage up” got us hollow tests. Make the real property (every side effect asserted) the thing that’s checked.

• The model can’t reliably hold the whole picture. It’s genuinely hard for an AI to read all the code and all the tests and be sure every boundary is exercised and every request and response fully asserted. Don’t ask it to. Build the check that guarantees it, and let the model iterate against clear failures.

• Reject, don’t cajole. A deterministic “rejected: uncited claim / unasserted produce / weak reason” beats a paragraph of pleading. The strict-retry loop did more than better wording ever did.

• Different models catch different things. A second (and third) model from a different lab, reviewing rather than writing, kills a surprising share of plausible-but-wrong output.

10. The moving target: forward-porting a live system

The rest of the team kept shipping features to the live Go system the whole time, so our target moved under us. We built sync tooling (migration/scripts/sync_from_master*.py) to continuously pull those changes in and forward-port them, using a per-file 3-way merge so local migration patches weren’t clobbered:

# migration/scripts/sync_from_master_3way.py, per changed file:
#   A (added)    → copy in
#   D (deleted)  → remove
#   M (modified) → git merge-file (3-way); leave <<<<<<< / ======= / >>>>>>> on conflict
# sync point tracked in migration/.last_master_sync; advanced manually after resolving

Because every ported change came with its own test, we were rebuilding the plane while everyone else kept flying it, safely.

11. Making thousands of real-infra tests fast

These aren’t mocked unit tests. They hit real ScyllaDB and Kafka, so parity is checked against real state changes. Running 7,000+ of them would be unbearable if each spun up its own containers. So the harness runs a resource-pool daemon (legacy/libraries/testharness/cmd/pool/main.go) that pre-warms a pool of Scylla and Kafka instances and leases them to tests, reusing each container across many runs instead of paying startup cost every time:

// legacy/libraries/testharness/cmd/pool/main.go
go scyllaPool.preWarm()
go kafkaPool.preWarm()
// instances are leased per test and returned; reuseCount tracks how many times
// each container is handed out, with idle-shrink and leaked-lease reclaim

It listens on localhost:19876, warms instances in the background, tracks per-instance reuse, reclaims leaked leases (a crashed test would otherwise hold a container forever), and shrinks the pool when idle. Keeping the infrastructure warm and reused let a 7,000-test, real-infra suite run in minutes instead of hours. That speed is what made the whole “let the agent iterate against the tests” loop viable at all.

One other fix worth a mention: moving the new TS service from kafkajs to Confluent’s librdkafka-based client surfaced that librdkafka requires topics to exist at subscribe time (unlike sarama and kafkajs, which auto-create). The fix was an ensureTopics() call via the admin API before subscribing, which also made consumer startup fast and deterministic.

12. Results

• About two weeks of migration (the main push in April 2026), against the 6-7 month human estimate.

• On the biggest day (14 April), a single run queued 47 targets, two at a time, and 23 came back green. Counting the handful finished the day before, roughly 27 in a day.

• ~7,500 trustworthy integration tests, every one asserting real behaviour.

• Live on Cloud Run, the old Go switched off, and because every service had to pass the exact same tests the old one passed, no behavioural regressions at cut-over. Safe, not just fast.

• The handover, when I went in for surgery, wasn’t a doc for humans. It was an AGENTS.md: the project’s living memory, written for the agents, so anyone could just run them:

# AGENTS.md (excerpt)
## Migration status: post-cutover
The Go→TS migration is complete. The TS monolith in `server/` is the sole runtime in
production; the legacy Go services have been decommissioned. `legacy/` remains only as a
read-only historical reference.

13. The point (and the human cost)

This isn’t really a migration story. It’s about how we work with AI now.

The AI is a brilliant worker, but it can be an unreliable one. It is never your source of truth. But give it an honest, unbluffable signal of whether it’s right, a check it can’t cheat, and you can make it do genuinely astonishing things. Here the old system defined “correct” and deterministic tests were the judge. The migrations that used to be too risky or too expensive to attempt just moved onto the table.

The one precondition, so nobody leaves overclaiming: this only works if you can define “correct.” No oracle, no safety. The real prerequisite isn’t a smarter model, it’s a verifiable definition of done. So the question to ask of your own work is: what’s my unbluffable check?

Don’t ask AI to be right. Build a way for it to prove it.

One honest coda: it isn’t free. Driving a swarm of agents that constantly cut corners is genuinely exhausting. The context-switching, the never-fully-trusting, the volume of output to review. It’s a real cognitive load and a real burnout risk, and if we’re going to work this way we need to take it seriously. But that’s another post.

For the past couple of years, the corporate world has been in an AI frenzy, with thousands of firms racing to implement the latest tools. But according to new research, only a slim 5% of companies are actually seeing a significant return on their investment.

We’ve seen plenty of organizations treat AI as a shiny new toy. However, the "Elite 5%" view it differently. Unlike those stuck in endless pilot programs, these leaders treat AI not as a standalone IT project, but as a core business strategy.

• The data shows a clear divide in how high-performers approach implementation.

• Organizational Integration: The 5% don't just "bolt on" AI; they redesign their workflows around it.

• Data Readiness: Successful firms ensure their data "foundations"are clean and accessible before they even touch a model.

The role of the leader is shifting from "adopter" to "value architect." Instead of simply automating tasks, top executives are focusing on:

• Strategic Alignment: Ensuring every AI initiative solves a specific, high-value business problem.

• Cultural Transformation: Investing in upskilling staff so the workforce can collaborate effectively with AI agents.

• Risk & Ethics: Building "Responsible AI" frameworks from day one to avoid costly reputational damage.

Real value from AI isn’t found in the technology itself, but in how deeply it is woven into the fabric of the business. To join the top 5%, you must move from experimentation to integration.

Read more of our insights on Business Reporter.

Listen to this article

0:00

/171.493875

1×

While AI is estimated to contribute $15 trillion to the global economy by 2030, our latest research reveals a significant disparity between AI's recognized potential and its actual implementation across industries. This adoption gap presents both a challenge and a strategic imperative for business leaders in 2024 and beyond.

The Current State of AI Adoption

Our research, which polled 415 business leaders and professionals and analyzed 21 sources and report across North America and Europe to paint a clear picture of the AI adoption landscape.

Most companies are still in the early phase of AI adoption. In our poll, 43% of companies reported still being in the early implementation phase and 15% reported being in the planning stage. Those who are in the mature implementation and leading stages of adoption make up a minority of 13% and 10% respectively.

This reflects a global trend across industry reports and underscores a significant disparity between AI's recognized potential and its actual implementation across industries.

📊

Interactive Chart Generated with Claude

The AI Adoption Gap

Most organizations remain in early stages, struggling to scale AI implementation

Select Location:

Mindstone

The Perception Problem: Limiting AI's Potential

Our research reveals a crucial insight into why this adoption gap persists: the overwhelming majority of professionals and business leaders see Automation and Process Optimization as the most valuable application of AI for their work.

While this is indeed a significant benefit, it represents only a fraction of AI's potential impact. This narrow focus on automation is significantly limiting the adoption stage, perceived value, and potential impact of AI in many organizations.

📊

Interactive Chart Generated with ChatGPT

The AI Benefit Perception Gap

Limited Views of AI Hold Back Widespread Adoption

¹Based on responses to the question: "What area of work do you think you could benefit most from AI?" AI adoption stages are not directly equivalent to company performance or AI capabilities. Source: Mindstone AI Adoption Survey 2024

Mindstone

Working research out of the University of California, Berkeley supports this view, highlighting that many leaders are stuck looking at AI through the lens of current tasks and processes. But this approach can only show small, incremental changes, missing the big picture of how AI could completely reshape how work is done.

By focusing too much on automating what already being done, laggards are essentially trying to predict the future by looking in the rearview mirror. To truly harness AI's power, organizations need to imagine entirely new possibilities, not just slightly better versions of what is done today.

Instead of starting with "How can AI do our current jobs?", leaders should ask, "How can AI create new forms of value for our business?". This shift in thinking opens up a world of strategic opportunities that go way beyond just cutting costs or speeding up old processes.

The Path Forward: From Implementation to Transformation

The AI adoption gap represents a pivotal moment for businesses across sectors. Organizations that successfully navigate these early implementation challenges, broaden their AI applications, and progress towards mature AI integration stand to gain significant competitive advantages.

"At a time when technology is driving unprecedented change, it is key to separate hype from reality and make strategic bets on AI to lead the next wave of innovation and transformation."
Joshua Wohle and Melinda Jacobs

Co-Chief Executive Officers, Mindstone Learning

Our report highlights that this approach is in step with the few companies who are leading in AI adoption and explores other key barriers and strategies to scale.

Bets and Moves: The real pulse of Generative AI in business

Mindstone’s State of Generative AI Q3 Report

Download the report

How We Used AI In This Post
In developing this post, we leveraged AI to synthesize information, generate interactive charts and images, generate audio for accessibility and optimize our titles and content.

The rise of AI brings with it an uncertain future for many professionals. How will AI shape the workforce? Will it replace jobs or transform them? The answer is unclear, but one thing is certain: preparing for a range of possible futures is key to thriving in an AI-driven world.

A strategy that has evolved and been proven effective for long-term planning and de-risking through uncertainty is scenario planning, originally developed by Shell. By applying these same methods, you can map out potential futures and develop strategies that minimize risk, no matter how AI evolves.

But where do you begin? There are 4 key strategic questions you need to ask yourself to get a clearer picture of the future and your place in it.

Future-Proof Your Career Now

Generative AI Foundations Certificate

Learn More

Q1: What’s Driving the Future of Work?

Before thinking about how AI might impact your career, it’s important to understand the forces shaping the future. From political decisions to social trends, here are the key factors that will influence how AI transforms industries and job roles.

How Will Governments Shape AI?

How governments choose to regulate AI will heavily influence its adoption. Countries like the EU are already developing frameworks, like the EU AI Act, to ensure ethical use, while other regions may allow free rein for AI innovation.

Impact: Tight regulations could slow down AI adoption, while a hands-off approach could accelerate it, leading to different levels of impact on jobs.

Will AI Be Affordable for Everyone?

The financial resources required to implement AI could create a divide between companies that can afford AI and those that cannot. AI could boost productivity and economic growth, but some sectors may struggle to keep up.

Impact: Companies that embrace AI will likely outpace competitors, creating new job opportunities, while others may face layoffs in non-automated sectors.

How Will People React to AI?

There’s widespread fear about AI displacing jobs, but some, like career coach Diego Rodríguez, emphasize that AI creates new opportunities. Rodríguez suggests, “AI won’t take our jobs, but it will change them.” The challenge lies in how quickly the workforce can adapt to AI-enhanced roles.

Impact: Those who upskill and embrace AI will thrive, while those resistant to change may be left behind.

Can AI Solve Big Problems, or Will It Hit a Wall?

AI technologies are advancing rapidly, particularly in areas like natural language processing and machine learning. However, some technical limitations remain, especially in replicating human-like creativity and emotional intelligence.

Impact: The faster AI advances, the more jobs it can automate, but this also creates opportunities for professionals to leverage AI for higher-order tasks.

How Will Privacy and Laws Impact AI’s Growth?

Regulations around data privacy and AI accountability could either drive or restrict AI’s impact on jobs. How governments enforce these laws will determine the scale of AI’s integration into the workforce.

Impact: Legal constraints might slow AI adoption, particularly in regulated industries like healthcare and finance.

Can AI Be Part of a Sustainable Future?

AI can optimize energy use and reduce waste, but it also consumes vast amounts of data and energy. As environmental regulations tighten, AI’s role in reducing the carbon footprint will be critical.

Impact: Companies may adopt AI as a tool for achieving sustainability goals, which could drive further investment in AI technologies

Q2: What Are the Biggest Uncertainties?

AI is full of unknowns, but two big questions will shape the future of work:

How fast will AI advance?

The rate of AI advancement and how widely will it be adopted across industries are critical uncertainties for all professionals. Will we see rapid development and adoption, or will progress be slower due to technical and regulatory barriers?

Will AI replace jobs or enhance them?

The verdict on whether AI will bring more displacement or transformation is still out and critical to the future of work across industries. Will AI primarily replace human jobs, leading to widespread unemployment, or will it enhance jobs by automating routine tasks and allowing humans to focus on creative and strategic roles?

These uncertainties create very different futures depending on how they play out.

Q3: Four Futures: Which One Will Shape Your Career?

Based on these uncertainties, we can imagine four very different future worlds. Each one presents its own challenges and opportunities.

Scenario 1: AI Takes Over – Will Your Job Be Automated?

In this scenario, there is rapid AI advancement and job displacement which leads to AI disruption. AI develops so quickly that it replaces a vast number of jobs across industries. From retail to finance, AI systems become capable of handling complex tasks, leaving many workers displaced.

Strategy:
In a world of rapid disruption, your best bet is to up/reskill quickly. Transition into AI-adjacent fields, like AI ethics, governance, or AI system management, where human oversight is still needed.

Scenario 2: Some Jobs Are Safe – Will Your Industry Be Hit Harder?

In this scenario, slow AI advancement and job displacement result in certain sectors seeing significant job losses as automation takes over. Other industries remain relatively untouched by AI, leading to uneven displacement across the economy.

Strategy:
Be prepared to move—whether to a different industry or region. In slower-adopting sectors, you’ll have more time to adapt, while those in faster-moving sectors may need to pivot quickly. Geographic and industry mobility could help you mitigate the uneven impact of AI.

Scenario 3: AI as Your Partner – How Will You Work with AI?

AI’s rapid advancement leads to jobs being transformed rather than eliminated leading to Human-AI Synergy. In this future, AI takes over routine tasks, allowing humans to focus on creativity, leadership, and strategy.

Strategy:
Mastering AI tools and collaborating with them will be key to success. By taking advantage of upskilling programs like the Generative AI Foundations Certificate, you prepare to integrate AI into your workflow, enhancing your productivity and focusing on higher-level tasks. Career guidance expert, Diego Rodríguez proposes this is a more likely scenario, stating that “AI can help us work less and produce more".

Scenario 4: Slow but Steady Change – Will You Have Time to Adapt?

In this version of the future, change is incremental as AI adoption happens gradually, giving workers more time to adapt. Jobs are transformed over a long period, with AI playing a supportive role rather than a disruptive one.

Strategy:
In this scenario, focus on continuous learning and building human-centric skills like creativity and emotional intelligence. While AI enhances roles, those who continue to develop human skills will remain indispensable.

Q4: What Can You Do Now to Stay Ahead?

No matter which future unfolds, there are key steps you can take to minimize risk and ensure you stay competitive.

Never Stop Learning: Upskill Yourself

AI is evolving, and so should you. Consider programs like the Generative AI Foundations Certificate to build the skills you need to stay relevant.

Double Down on What AI Can’t Do

Creativity, emotional intelligence, and leadership are human skills that AI can’t easily replace. Focus on developing these strengths.

Be Ready to Pivot

Flexibility is your greatest asset. Be open to moving industries, roles, or even locations as AI shapes the future of work.

While these are broad scenarios, AI’s impact will vary based on your industry, role, and location. Now is the time to think about how these futures might affect your field and plan accordingly. Being proactive will help you stay ahead of the curve.

The good news is that AI experts like Diego Rodríguez are optimistic, suggesting that AI will change jobs rather than eliminate them. Regardless of whether you share that optimism, the best way to prepare is to upskill, focus on what AI can’t do, and stay flexible. By following these strategies, you’ll be ready to thrive in any future the AI-driven world presents.

Get the AI skills to stay ahead in your career

How We Used AI In This Post
In developing this article, we leveraged AI to enhance the research and content creation process, combining the best of human creativity with AI’s ability to process information efficiently.

Here’s how we used AI for different stages:
Research: AI helped gather and analyze trends quickly, allowing us to focus on the most relevant insights.
Content Structuring: AI-assisted tools helped organize the article for clarity and readability.
Headline Optimization: We used AI to test and refine headlines, ensuring they were engaging and effective.
Editing: AI tools supported grammar and style checks, while human editors made the final content decisions.

LONDON – 1 October 2024: Mindstone, a global training platform and community focused on the practical use of Artificial Intelligence (AI) for non-technical staff, and leading learning company Pearson have partnered to launch Pearson’s new Generative AI Certification program. This collaboration combines Pearson’s expertise in education and certification with Mindstone’s proficiency in practical AI application, creating a comprehensive solution for AI upskilling across industries.

As AI becomes increasingly ubiquitous in the workplace, proficiency in AI tools is rapidly becoming as essential as competence in Microsoft Office. This shift has led to soaring demand for practical AI skills, with employers now expecting a baseline level of AI literacy from their workforce. The World Economic Forum predicts 75% of companies plan to adopt AI technologies by 2027, however, a significant gap often exists between academic AI knowledge and its real-world application. Mindstone and Pearson are directly addressing this disconnect by offering training and credentialing that bridges theory and practice, validating both the theoretical understanding and practical competence in AI that today’s professionals need to thrive in an AI-driven work environment.

Pearson’s new Generative AI Certification program, launched on October 1, 2024, is industry- and tool-agnostic, making it relevant for professionals across all sectors. Mindstone has played a key role in ensuring the certification is aligned with industry needs. Additionally, Mindstone will provide Generative AI training courses aligned with the certification, ensuring that candidates gain practical Generative AI skills and reach the required proficiency to successfully complete the certification.

The AI Certification program assesses a comprehensive range of skills and knowledge areas crucial for practical AI application in the workplace. This includes a deep understanding of how AI works, ethical considerations and risk management in AI deployment, various use cases across industries, and core techniques to maximise AI’s potential in daily work. What sets this certification apart is its strong emphasis on practical application, ensuring that certified professionals not only understand AI concepts but can effectively leverage AI to enhance productivity.

The certification will be evaluated every six months to keep pace with innovation and AI trends. 

“We’re excited to join forces with Pearson to create a world-first, globally recognised AI certification,” said Joshua Wöhle, CEO and Co-Founder at Mindstone. “Our expertise in practical AI application, combined with Pearson’s unparalleled experience in certification and education, will provide professionals with a credible way to demonstrate their AI competency. This partnership represents a significant step in our mission to equip the global workforce with the AI skills needed for the future.”

Gary Gates, managing director for Pearson VUE and Certiport said, “Working with Mindstone is another example of how Pearson collaborates across the industry to stay at the forefront of technologies like Generative AI. Bringing essential AI education to people through professional certification and credentialing programs helps them realize the life they imagine through learning.”

About Mindstone

Mindstone is an AI training platform that unlocks 60%+ productivity gains for your business by training your non-technical staff to use AI in their daily jobs. We combine our best-in-class personalised learning technology (which itself leverages a ton of AI under-the-hood to improve the learning experience), with learnings from running the biggest practical AI community in the world.

In today’s rapidly changing business environment, artificial intelligence (AI) is no longer just a tool; it’s becoming a vital partner in driving innovation and efficiency. But the real revolution isn’t about machines taking over jobs; it’s about AI working alongside humans to reshape the way we think about productivity and innovation.

Jonathan Gilmore, CEO of Fractal explained how AI’s role in business goes beyond automation at the Mindstone's London AI Meetup, demonstrating how human-machine collaboration is set to redefine the future of work.

Explore Now: Free AI Use Case Finder

Rethinking Work: Collaboration, Not Replacement

For years, the conversation around AI has been dominated by the fear of the robots taking our jobs.

In some way, this automation anxiety has not been completely unfounded with reports of some companies reducing personnel for work that is now done by AI this year. However, Gilmore and other experts like Stanford University's Behnam Tabrizi and NinjaTech AI's founder Babak Pahlavan suggest this is a short-sighted strategy and a narrow way to look at AI’s potential.

While machines handle high-volume data and routine processes with efficiency, evidence still suggests that AI does not consistently make better decisions than humans, particularly when it comes to complex judgments involving human factors.

As businesses increasingly adopt AI technologies, many are discovering that success is not simply about delegating tasks to machines or humans based on who can do it better. Instead, Jonathan Gilmore posits that navigating the future of work means learning how to surf the jagged frontier.

Originally coined by Ethan Mollick et al., a leading voice on AI’s impact on work, the jagged frontier is the shifting, uneven boundary where AI capabilities and human intervention intersect in ways that are more nuanced than a simple division of labor.

The AI ROI Gap: Why Businesses Aren’t Reaching Full Potential

Gilmore emphasizes that companies need to rethink their organizational structures to ensure that human and machine collaboration is fluid and dynamic.

If businesses want to surf the jagged frontier, they must move beyond traditional workflows and embrace adaptive systems that can seamlessly switch between human and AI leadership, depending on the task at hand.

However, successfully reengineering organizational design starts with a strong foundation of AI competency. Both employees and management must understand basic familiarity with AI tools as well as build a deep understanding of how AI fits into larger systems. This means understanding how AI transforms processes and rethinking the way teams work.

Explore Now

The Blueprint for Thriving Human-Machine Teams

Teams need to be educated not only on how to operate AI systems, but also on how to collaborate effectively with AI in real-time, identifying when AI outputs need refinement or when human oversight is necessary for tasks that involve complex decision-making.

As Gilmore suggests, companies cannot succeed with AI by simply adopting new tools. The key to thriving in the age of AI lies in redesigning the organization to foster human-machine collaboration and grounding that shift in comprehensive AI competency training.

By doing so, organizations will empower their teams to work alongside AI—not just as users of technology, but as strategic collaborators who understand how to harness AI’s potential to drive meaningful business outcomes.

How We Used AI In This Post
This post was developed with the assistance of AI tools, which were used to streamline content creation and research.

Specifically, AI helped in summarizing key points, structure the narrative, and improve clarity. While human insight and strategy were essential in shaping the final narrative, AI played a key role in enhancing productivity and ensuring thorough coverage of the topic.

This collaborative process between human creativity and AI efficiency reflects the very themes discussed throughout the post.

Discover Your AI Use Case for Free

Mindstone AI MeetUp: Discover the ideas, innovations, and practical insights that matter.

From booking errors that strand passengers to "hiring" bots over humans, the real-world impact of AI is hitting faster than expected – and raising a minefield of ethical dilemmas.

But while laws and regulations lag behind, the tech giants at the cutting edge of AI aim to police themselves, with an insider framework called the Presidio Principles.

Cutting through the complexity, their guidelines boil down to four key points every organization using or building AI needs to get right:

1. Making AI's purpose all about empowering humans, not replacing them

2. Prioritizing transparency so we understand how AI makes decisions

3. Establishing clear ownership of the data that fuels AI systems

4. Always disclosing to users when they are interacting with non-human AI

Ethics advisor Guillermo Miranda, who has worked with the likes of IBM and Boeing, unpacks why each of these principles is critical to keeping AI ethical and beneficial as it grows increasingly advanced – and how to practically apply them in the real world.

For leaders, innovators, and anyone seeking to harness AI's potential without stepping on ethical landmines, Miranda's breakdown of the Presidio Principles isn't just fascinating – it's an essential roadmap for navigating one of the most important issues of our time.

Don't deploy AI without considering these vital guardrails. Check out the full talk now to put the Presidio Principles into practice.

Mindstone

In the pressure cooker of a major IT meltdown, every decision feels like life or death. The margin between catastrophe and control? Training. In this pulse-pounding talk, Uptime Labs mastermind Joe Mckevitt unveils how his team is harnessing AI to forge cool-headed crisis commanders through hyper-realistic, interactive incident simulations.

Ripping a page from the playbooks of pilots and firefighters, Uptime Labs has constructed a virtual crucible where IT responders are baptized by fire. Fueled by cutting-edge language models, learners are dropped into a meticulously simulated company, complete with living, breathing Slack channels and AI-powered characters with all-too-human quirks. Here, they must detect the smoke of disaster, rally virtual teams to douse the flames, and emerge victorious - or watch it all burn down.

With a technical deep-dive that feels like a thrilling heist, Joe reveals the AI alchemy animating these uncannily immersive worlds. From parsing intent to spinning up sprawling webs of memory across scores of characters, you'll see the breakthroughs breaking down the barriers between simulation and reality.

But brace yourself for the main event: a live demo that packs the emotional punch of a Hollywood blockbuster into five unforgettable minutes. You'll feel the heat of the spotlight, the rush of adrenaline, the sweet relief of disaster narrowly diverted.

Yet even as the smoke clears, Joe has his eyes on the horizon. A world where video and audio blur the seams of illusion, where bias is hunted down and eradicated, where each drill dials up the intensity until unshakable confidence is forged. Where trauma-tempered veterans are minted without the scars.

If you're a first responder in the digital trenches, a crafter of mind-bending learning experiences, or simply electrified by the transformative might of AI, this is your call to adventure. Step into the fire and witness the future of crisis response - and the power of AI to reforge reality - in this unforgettable odyssey.

Mindstone

Imagine a world where captivating learning games on any subject materialize out of thin air, conjured by the power of AI. In this jaw-dropping live demo, GPT wizard Joshua Wöhle takes you on a journey to the frontier of educational experience design, where the only limit is your imagination.

Witness the astonishing alchemy of GPT as Joshua transforms a humdrum article into a multi-dimensional learning odyssey, complete with risk, reward, and real-time feedback. Marvel as complex game mechanics emerges from a few simple prompts, painting a vivid picture of AI's untapped potential.

But the real gold lies in the secrets Joshua unveils along the way. Gleaned from countless hours in the GPT trenches, his hard-won techniques for optimizing language model output will make you rethink everything you know about AI. From the arcane art of chain of thought reasoning to the surprising power of emotional cues, Joshua leaves no stone unturned in his quest to bend GPT to his will.

The magic reaches a crescendo when the audience steps into the circle, their ideas and inspirations fuel for GPT's relentless creativity engine. Behold the birth of a learning experience like no other, a living testament to the power of human-AI collaboration.

Whether you're a learning professional, a business leader, or simply someone who's hungry to glimpse the future, this talk is a clarion call. It's a invitation to reimagine what's possible when the ancient craft of teaching merges with the awesome might of artificial intelligence. Witness the revolution for yourself - watch the full demo now and be forever changed.

Mindstone

The AI gold rush is on - but beneath the glitter lies a labyrinth of legal tripwires. In this indispensable talk, tech law maestro Natasha Ahmed is your guide through the maze, shining a light on the hidden hazards threatening to ensnare the unprepared.

From the quagmire of IP rights in training data to the quicksand of AI output ownership, Natasha unearths the legal sinkholes that can swallow businesses whole. She exposes how casual AI use can quietly poison the wells of privacy, confidentiality, and security.

With lawmakers and regulators lost in the labyrinth themselves, businesses are left to navigate by dead reckoning. Can you trust vendor terms to be your compass, or are they leading you further astray? Is your team unwittingly leaving a trail of confidential crumbs for others to follow?

But Natasha isn't just the bearer of bad news - she's your cartographer for this treacherous new territory. She maps out the must-have provisions in vendor contracts, the internal policies that fortify your defenses, and the training that keeps your team on the right path.

Packed with cautionary tales and battle-tested strategies, this talk is both a dire warning and an empowering toolkit. Whether you're an AI trailblazer, a corporate leader, or just trying to chart a safe course in this brave new world, this unflinching look at AI's legal landscape is your essential guide. Watch now and ensure your business journey doesn't end in a legal dead end.

Mindstone

In the age of privacy and compliance, open-source AI isn't just an alternative - it's an imperative. In this code-level expedition, AI infrastructure trailblazer Paul Hetherington takes you step-by-step through building a private, open-source chatbot that goes toe-to-toe with ChatGPT.

Uncover the transformative potential of Retrieval Augmented Generation (RAG), the secret weapon that allows open-source language models to draw upon real-time data. Paul unboxes an arsenal of tools, from vector databases to Redis to Google's Custom Search API, equipping you to construct an information retrieval powerhouse.

But this isn't just theory. Strap in as Paul conducts a live demo of a fully-private, open-source chatbot, showcasing the jaw-dropping capabilities of the newest open-source models. Witness why data quality trumps model size in the quest for AI performance.

Paul confronts the elephants in the room, from the ever-present specter of context length limitations to the whiplash-inducing velocity of open-source model evolution. He distills hard-won wisdom, arguing for a ruthless focus on product and UX, and enlisting battle-tested tools to tame the beast of deployment.

Whether you're in the trenches of ML engineering, at the helm of an AI startup, or simply electrified by the future of open-source AI, this talk is a wellspring of epiphanies. Join the full session to learn how to wield the might of open-source AI while conquering its most daunting challenges. The age of private AI supremacy is here.

Mindstone

What if you could transform your unique expertise into a thriving digital product business - without any design or tech skills? In this game-changing talk, consultant Burça Bulut Ozan lays out a simple, AI-powered system for turning what you know into what you sell.

Step into a world of possibilities as Burça reveals the digital products that are ripe for the making, from eye-catching printables to in-demand online guides. She demonstrates how to brainstorm winning product ideas and pinpoint the perfect selling platforms, all with the help of ChatGPT.

But the real magic happens when Burça unveils how AI tools like DALL-E and user-friendly platforms like Canva eliminate the need for design chops. She walks you through crafting irresistible visuals and product layouts that sell themselves.

The proof is in the pudding: Burça shares real-life examples of digital products hitting it big on Etsy and beyond. She breaks down the secrets to success, from carving out an original niche to riding the waves of trends.

If you're tired of letting your valuable know-how gather dust, this talk will show you how to spin it into digital gold. Watch the full session now to unlock a step-by-step roadmap for building a profitable digital product empire, no experience necessary. Your knowledge has never been more valuable.

Mindstone

What do a private equity powerhouse, a VC trailblazer, a serial entrepreneur, and a top startup lawyer have in common? A front-row seat to the AI revolution reshaping the startup landscape. In this game-changing panel discussion, four industry insiders pull back the curtain on the real story behind AI's startup invasion.

Discover why AI adoption has skyrocketed among startups, jumping from 20% to 60% in just one year. The investors unveil the AI innovations capturing their attention and checkbooks, from cutting-edge infrastructure to AI-powered features that dazzle customers.

But it's not all unicorns and IPOs. The panelists also bare the scars of hard-fought battles in the AI arena, sharing candid stories of investments that soared and soured. They compare notes on the diverging US and UK AI startup scenes and divulge their predictions for the coming year.

For anyone seeking an edge in the startup world, this panel is a rare chance to absorb wisdom from investors at the peak of their game. Whether you're an ambitious founder, a savvy investor, or captivated by the future unfolding before our eyes, you won't want to miss these revelations. Watch the full discussion now to glimpse the emerging trends, looming challenges, and extraordinary opportunities ahead.

Mindstone

Imagine if developing a complete, fully-functional piece of software took minutes instead of months and required no coding skills. In this mind-expanding talk, Robert C. demonstrates how this is now possible through the power of collaborating AI agents.

Forget what you know about AI language models working in isolation. Robert explains how teams of specialized AI agents, when working in concert, can tackle complex software projects with unprecedented speed and quality. The latest research proves it: multi-agent systems consistently trounce solo agents.

But the real magic happens when Robert introduces Chatforce, a groundbreaking platform that lets anyone assemble and direct AI teams to build real software. In a live demo, Robert uses Chatforce to create a complete game in just 20 minutes, for a mere $2, all without writing a line of code himself.

Whether you're a software developer, business leader, or just curious about the future of AI, this talk is a must-see. Watch now to witness the staggering implications of accessible, multi-agent AI systems in action. The era of AI-accelerated software development is here - are you ready?

Mindstone

Imagine having the power of ChatGPT on your personal computer, usable anytime, anywhere, without your data ever hitting the cloud. In this game-changing talk, tech leader Joshua Wohle shows you how to get state-of-the-art AI running on your laptop in minutes, zero coding skills required.

Through a live demo, you'll see advanced language models executing locally on a basic MacBook Air - no developers, cloud servers, or fancy hardware needed. Wohle breaks down how this puts cutting-edge AI in the hands of everyone, with huge implications:

• Total privacy: your data never leaves your machine

• Offline access: get AI assistance with or without internet

• Accessibility: AI superpowers are no longer limited to programmers

Whether you want to experience the magic of local AI yourself or explore the possibilities it unlocks, this talk is a must-see. Check out the complete session now to get started.

Mindstone

Worried superintelligent AI will outsmart and replace us? This data scientist argues evolution tells a different story.

In this talk, Akshaya Kadidal reveals how the cockroach has survived human extermination attempts for centuries despite our god-like intelligence. He shares the surprising fact that 99% of species went extinct before neurons even evolved.

Current AI may be smart, but Kadidal contends it lacks the resilience, curiosity and creativity forged by eons of evolutionary pressure that allowed the 1% to flourish.

But humanity's real superpower? Our unparalleled ability to cooperate flexibly at scale. This edge let us best the Neanderthals and achieve wonders like the pyramids.

Will we outsmart our AI creations or be outsmarted by them? See the evolutionary case for betting on Team Human in the full talk.

Mindstone