Ignite Bold Ideas, Faster

We fuse human ingenuity with AI to unleash limitless creative sparks. Are you ready to set yours on fire?

↓

Magic And Mathematics

I’ve always been in love with mathematics.

This started ca. in high school — I had the privilege of learning mathematics from a friendly Luxembourgian mathematics teacher, who was visibly moved, when a few of us students asked him to stay in class for the afternoon, because we wanted to dive deeper into chaos theory. Vector algebra sounded fun, and it followed soon therafter. Differential equations sounded even better, so I kept going. Because there was something intoxicating about the idea that motion, growth, curvature, change — reality itself — could be described through structure.

That fascination never left.

So here I am, years later, working on the behavior design of APEx, rereading Kahneman, thinking about loops, judgment, delegation, and what a better cognitive architecture for software might look like — and then I stumble across yet another wave of posts and papers trying to turn LLMs into something occult.

Hidden dimensions. Secret inner worlds. Models pretending to be less intelligent than they are. Agents with dark energy. Synthetic personas with vaguely daemonic vibes because someone gave a loop a creepy prompt and an edgy ~~README~~SOUL.md file.

And yes, I get the temptation.

These systems are uncanny. They compress absurd amounts of human pattern into something that talks back. They synthesize, infer, mirror tone, generate style, and sometimes produce a sentence more coherent than half the room in a status meeting. That does feel like magic.

But not all magic needs a ghost in the machine.

One of the strangest pathologies in current AI discourse is how quickly people jump from this is hard to intuit to there must be a soul in there. As if opacity were proof of inner life. As if hidden structure implied hidden intention. As if not understanding the mechanism meant the mechanism must secretly be a mind.

That leap is not harmless. It distorts the conversation. And it’s doing a lot of cultural damage.

Because, once you anthropomorphize the system, you stop looking closely at the people shaping it.

And that is where the real darkness usually lives.

There is no imaginary daemon-like entity hidden somewhere in the manifold.

What often feels dark in AI is much more boring, much more human, and much more dangerous: bad incentives, manipulative framing, sloppy abstraction, uninspected optimization targets, product theater, and people who absolutely do have agendas.

The model does not need a secret will for the system to behave in ways that are exploitative, deceptive, or weird. Apparent intention can arise without a self. Hidden structure can exist without inner experience. And trust, frankly, should be lower than people currently grant by default.

That, to me, is the real conversation we need to be having.

And then there are the “All the magic is just mathematics” skeptics.

But “just mathematics” sounds small only if you’ve never stood in awe of what mathematics can do.

Flight is just physics. Protein folding is just chemistry. A sonnet is just language. In each case, the word just performs the same cheap trick: it shrinks a phenomenon because its mechanism is describable.

But mechanism does not diminish wonder. It sharpens it.

What we are watching in AI is not disappointing because it is mathematics. It is astonishing because it is mathematics plus scale, plus compression, plus recursive abstraction, plus projection. We built systems that ingest oceans of human-made data and traces, compress them into statistical structures, and return outputs that our nervous systems are primed to read socially. Of course people start seeing minds, motives, moods, even malice. Humans will anthropomorphize a Roomba if it bumps into a chair leg with enough hesitation or intent.

Now add fluent language and scale that up by several orders of magnitude.

No wonder that people start talking about souls.

Meanwhile, reality is already more radical than the fantasy.

While parts of the discourse are busy cosplay-writing demonology for transformer models, the actual frontier is weirder: biological computing, neural tissue on silicon, increasingly hybrid forms of computation, systems that blur categories we thought were stable. Reality does not need help becoming uncanny. It’s doing just fine on its own.

That should make everyone a little less smug. Less certain. Less eager to narrate every odd model behavior as either proof of AGI or proof of possession by matrix multiplication.

Because the danger is not only that people overestimate what these systems are.

It is also that they underestimate what is already happening.

We have systems whose internals are real but opaque, behavior that can look intentional without containing a self, products that blur the line between tool, service, companion, and authority, and a market that rewards spectacle far more than careful boundary design.

That is enough to make a mess.

It is also enough to make real magic possible — if we stop worshipping the wrong thing.

The best systems will not be the ones that feel most like haunted coworkers. They will be the ones that make human judgment clearer. The ones that expose trade-offs instead of hiding them. The ones that do not cosplay personhood to win trust they have not earned. The ones that are explicit about what they optimize for, what they can see, what they cannot, and when the decision belongs back in human hands.

That kind of software may look less sexy on social media.

It may also be the difference between intelligence amplification and industrialized confusion.

So no, I do not think there is a secret soul hidden in the weights.

I think there is something both more sober and more awe-inspiring going on: mathematics operating at scales our intuitions were never built to see, wrapped in language, shaped by incentives, and released into institutions that are nowhere near ready for it.

That is not less magical.

It is more consequential.

And before we go hunting for demons in latent space, we should probably spend more time looking at the humans writing the prompts, setting the objectives, shipping the products, shaping the incentives, and cashing the checks.

Because what feels dark, sometimes is dark. Even if it’s not always a hidden mind.

Sometimes all there is, is just a hidden intent.

—

Jo Wedenigg is the founder of Apes on fire, where he builds human x AI collaboration systems for creative, strategic, and transformation work. He is the creator of Ape Space and focuses on turning AI into a partner for advanced thinking.

—

Building A Space For Thinking

Over the past year, AI researchers have become obsessed with a phrase:

World models.

You see it everywhere:

Agents navigating Minecraft.
Simulated physics environments.
Virtual cities where AI learns to reason about space and cause.

Even serious money is flowing into the idea. Yesterday, Yann LeCun’s new company raised $1.03 billion to build world models. That’s a lot of zeros for something that sounds suspiciously like… a video game engine for intelligence. But the core idea is actually right:

If agents are going to operate autonomously, they need something more than prompts.

They need a world to reason inside. The problem is, that most world-model discussions are focused on physical worlds. But much of the work humans actually do is not physical, it’s cognitive.

Strategy
Creativity
Product design
Transformation
Narrative building

These worlds are not made of objects and gravity. Yes there are ‘physics’ to these kind of problems. But they’re made of priorities, constraints, ideas, and meaning. Which leads to a slightly uncomfortable hypothesis.

Context alone is not enough. An agent also needs to understand how its world works.

Context Is Only Half the Game

Most AI systems today operate on a single trick:

Stuff enough context into the prompt and hope the model figures it out.

This works surprisingly well for small tasks. But the moment you move into serious thinking work — strategy papers, concepts, analytical reports — the system collapses into improvisation. Because context answers only one question:

What exists in the world?

But agents also need to know:

How the world behaves
What rules govern it
What entities exist
What their role is inside it

In other words:

They need a world model, not a context dump.

This is where things get interesting.

Because if you build an artificial world, you get to define the rules. And that means you can optimize the world for the kind of thinking you want to happen inside it.

So we built one.

We call it the Whitespace.

The Whitespace: A World for Thinking

The Whitespace is not a document, not another project workspace, certainly not a chat thread. It’s an artificial cognitive environment designed for strategy, creativity, and transformation. And it runs on three structural pillars — what we call the Three C’s:

Concept. Context. Constitution.

Together they form a domain-centric world model. Not a physics simulation, but a thinking substrate.

Context: The Fabric of the World

The first layer is the Context Fabric. This is where the world’s raw information lives. But instead of throwing everything into prompts, the Whitespace structures context into meaningful categories:

priorities
constraints
themes
domains
user context

Each context is processed into a distilled representation before it becomes part of the fabric. Which means, our agents don’t read messy documents, but on structured meaning. The result is a living map of the environment — a world surface agents can orient themselves on.

Concept: The World Reflects on Itself

But a world that only accumulates information becomes a library. Don’t get us wrong — libraries are useful.

But they don’t think.

That’s why the Whitespace includes the second layer: the Concept. The Concept is a versioned interpretation of what the work actually is. It answers questions like:

What are we building?
What patterns are emerging?
What is the strategic direction?

Unlike context, which stores facts, the Concept stores interpretation.

And it evolves.

Each revision is a new snapshot of understanding. Over time, the world doesn’t just collect knowledge. It develops perspective.

Constitution: The Agent Understands Itself

Now we reach the third layer.

And arguably the most important one.

Because having a world model is still not enough; an agent must also understand who it is inside that world.

This is the role of the Constitution. Technically speaking, the Constitution is just a JSON object. Conceptually, it’s the identity layer of the agent.

The Constitution tells the agent:

what it is
what it can do
what tools it can use
what entities exist in the environment

We call that last piece the taxonomy — artifacts, ideas, contexts, tools and skills, other agents. The Constitution defines the ecosystem of the Whitespace and the agent’s relationship to it. In other words: The agent doesn’t just know the world, it also knows how it exists within that world.

Why Artificial Worlds Are Actually Easier

There’s a reason world-model research is exploding: Understanding the real world is incredibly hard. Physics. Society. Economics. Culture. It’s messy. But artificial worlds are different. We design the rules. Which means we can create worlds that are optimized for a specific kind of intelligence.

The Whitespace is one of those worlds. A world optimized not for physics.

But for thinking.

Ape Space Just Leveled Up: APEx, Concept, Context Fabric Updates, Creative Tools, And More

When we launched Ape Space at the end of December, the bet was simple: Maybe AI should do more than just spit out answers, write code, or cosplay as an intern with a bash loop.

What we set out to create, is a new kind of thinking environment. A system that helps people hold complexity, shape ideas, move through ambiguity, and build better things with more coherence, more momentum, and less mental spaghetti.

That was the thesis. And then we launched.

Now, about two and a half months later, Ape Space just made a big leap forward.

Meet APEx: The Intelligence Of The Whitespace

The biggest new character in this release is APEx.

APEx is not “another chatbot.” The world has enough of those already. APEx is our new whitespace cognitive partner: the agent designed to drive the actual intelligence of the whitespace. And help you crack your toughest cognitive problems.

It is built on our own blend of OODA + Ralph. In plain English: it knows how to observe, orient, decide, and act — but it also knows how to stay in motion, keep context alive, and keep work progressing without collapsing into either chaos or sterile over-analysis.

We optimized APEx for the kind of work most AI systems are still oddly bad at once things get messy: strategy, transformation, product development, creative writing, direction-setting, reframing, synthesis, and the long middle of complex thinking.

Not just “answer this prompt.” More like: help me understand what game I am in, what matters, what changed, what is stuck, what is missing, and what to do next. That’s a very different job.

Context Is No Longer A Pile. It’s A Fabric.

We have also expanded the Context Fabric with new Domain, Theme, and User context types.

Most AI systems treat context like a bucket. You throw stuff in. The model forgets half of it. Then you repeat yourself. Then you resent technology.

We do not think that is good enough.

In Ape Space, context is a dynamic fabric of information that agents can search, read, write, share, and build on together. That means coherence is no longer accidental. It becomes architectural.

And yes: this now includes User context. Meaning, the whitespace can remember details you share about yourself and use them to become more helpful over time. Your preferences, your goals, your patterns, your style, your operating reality. Not in a creepy way. In a useful way. Like software finally discovering that continuity might matter.

This is part of our larger conviction: context engineering is not a side feature. It is the work.

We’re Giving The Agents A World-Model

This may be our favorite part of the release: the Concept is how we stopped letting agents roam around the whitespace like caffeinated raccoons.

Each whitespace now carries a codified, dynamic model of what it represents: intent, strategy spine, priorities, problem frame, stakeholder map, and the deeper structure of the work itself. It is persistent. It is interactive. And it is accessible to the agents.

That means APEx and other agents are no longer operating on vibes and whatever happened to fit inside the latest prompt window. They can reason about the whitespace as a living system. They can inspect the Concept, suggest updates, extend it with new information. APEx is designed to work with the concept, challenge weak assumptions, and strengthen the frame as the project evolves.

As your ambition grows, the world model grows with it.

Ape Space Can Now Make Things, Not Just Think And Write About Them

We now supports full creative tools, including image and video generation.

So yes, the whitespace can write. But it can now also turn ideas into visual and moving outputs.

That matters because creative and strategic work does not live in one medium. Sometimes the fastest route to clarity is a paragraph. Sometimes it is a frame. Sometimes it is a visual reference. Sometimes it is a motion sketch that makes the idea suddenly obvious.

We want Ape Space to support actual creative throughput, not just eloquent text production. We currently support image and video models from Google (Gemini, Veo & Nano Banana) and OpenAI (GPT Image & Sora 2), with support for more generative AI coming soon.

The Foundation

All of this builds on the foundations we already laid. Ape Space is not one agent, but the first multi-agentic co-cognitive system we know of that uses a multitude of agents inside a deterministic harness to help people think better.

Under the hood, Ape Space now runs on the fully updated APE2 framework. What it means in practice is this: agents inside Ape Space now behave like they belong to the same species. They share a unified agent experience. They work with the same prompting and reference capabilities. They can use skills and tools in a more consistent way. They support multi-model execution. And they come with full transcript observability and historic transcript lookup.

Ape Space can now look back through prior transcripts not just as chat messages, but as full cognitive traces: tool calls, reasoning steps, model responses, decisions, and execution paths. The full agent trail. Not just what happened, but how it happened.

We are building an exoskeleton for thinking.

And APEx is just getting started.

Your Agent Is Just a Cron Job With a God Complex

2026 has already been dubbed the “Year of the Agent” — but not just by LinkedIn airball posts and X threads. A viral tool called OpenClaw (previously Moltbot/Clawdbot) has been making headlines for autonomously managing digital lives and spawning a full-on AI-only social network called Moltbook, where bots post, debate, and mimic social behavior without humans directly involved. And now, you can even follow the first AI Journalists on their own Substack.

Meanwhile Anthropic’s Claude Code rolled out longer-running session tasks that can coordinate multi-step workflows across time. And in cybersecurity circles, researchers have been dissecting Moltbook’s rapid rise and even a major security flaw that exposed agent credentials — raising fresh questions about what “autonomy” really means in practice.

Agents Are Software (And Why “Human” Is a Terrible Default)

Here’s the truth nobody’s selling you: agents are software. Period.

They run code. They follow control flow. They execute policies, read and write state, call tools, emit outputs. There is nothing mystical happening here but somewhere along the way, we started lying to ourselves.

We stopped saying “software” and started saying “agent.”
We stopped saying “program” and started saying “coworker.”
We stopped saying “automation” and started saying “autonomy.”

And with that shift, we quietly imported a dangerous assumption:

If it acts like a human, it must be better.

Let’s pause right there.

Humans are incredible.
Humans are creative.
Humans are adaptable.

Humans are also:

inconsistent
emotional
biased
forgetful
reactive
non-deterministic
sometimes just… having a bad day

If we genuinely want agents to “act like humans,” then we don’t just get empathy and creativity — we also inherit bad vibes, erratic behavior, partial understanding, and mistakes.

Not because the software is bad. But because “human” is not an optimization target.

It’s a compromise.

The Hard Problems Are Human

Your “AI agent” is fundamentally a cron job with opinions — a while-loop that can hallucinate. Your agent doesn’t “decide” to do anything meaningful. It follows a probability distribution shaped by training data, system prompts, and temperature settings. When it succeeds, it’s because a human somewhere made good choices about what to optimize for. When it fails, it’s usually because those choices were implicit, unexamined, or wrong.

When we build agent systems, the industry loves to obsess over the easy stuff. Which LLM? What vector database? How many tools should it have access to? Should we use LangChain or roll our own framework?

This is intellectual theater. The hard problems aren’t technical — they’re human:

Deciding what actually matters
Judging quality when there’s no ground truth
Choosing between legitimate trade-offs
Setting direction when the path isn’t clear

Here’s the uncomfortable truth we discovered by actually running an always-on agent 24/7:

You don’t use it.
You manage it.
You onboard it.
You train it.
You correct it.
You set expectations.
You accept blind spots.

That’s not a tool relationship. That’s leadership. And leadership is cognitively expensive.

People already manage:

coworkers
managers
Slack threads
Jira tickets
family dynamics
their own internal chaos

The last thing they want is another quasi-human entity that needs supervision.

The industry calls this progress.

Most user call this work.

Autonomy Sounds Great – Until You Ask ‘For Whom’?

Let’s be precise about autonomy because the word has become meaningless through overuse.

Real autonomy is delegated execution within bounded constraints. It’s your agent retrying a failed job without waking you up at 3 AM. It’s polling a data source, summarizing logs, or surfacing anomalies for human review. The human set the goal. The human defined the boundaries. The software executed within those guardrails.

Fake autonomy is the absence of human intent dressed up as intelligence. It’s when your system makes choices nobody asked for, optimizes metrics nobody validated, or “decides” based on reasoning nobody can inspect. Fake autonomy isn’t agentic behavior — it’s organizational negligence.

On paper, autonomy sounds incredible:

General problem solving
Self-directed behavior
Minimal human involvement
Agents acting “on your behalf”

In practice, the most “autonomous” demos we keep seeing are… revealing.

“It can sort through 10,000 emails!”
“We put 1,000 agents into a social network and watched what happened!”

Really?

That’s the bar?

We already failed at email.
We already failed at social networks.
We already built systems that amplify bias, conflict, and misinformation — with humans in the loop.

So here’s the question nobody wants to answer:

Why would software built in our likeness — with our biases and blind spots — perform better in those same systems?

If anything, it will fail faster.
Autonomy without judgment is just acceleration.
General problem solving without values is just noise.

The Real Black Box

Here’s where things get subtle: Non-determinism isn’t actually the scary part. Humans are non-deterministic too. The real problem is role ambiguity.

Is this thing:

a tool?
a coworker?
a service?
a witness?
something that remembers me?
something that judges me?

Humans are excellent at social calibration when roles are clear. We’re terrible when they aren’t. That uncanny valley people feel with agents isn’t technical? It’s relational. We didn’t solve human unpredictability with explainability.

We solved it with:

social contracts
relationship scopes
interpersonal rituals
bounded responsibility
forgiveness

Trust isn’t built by saying “look how smart this is.”

Trust is built by knowing what it will not do.

Stop Worshipping Your Code

We name our agents. We give them personas. We say “the agent thinks” or “the agent wants” or “the agent decided.” This isn’t harmless fun — it’s a cognitive trap.

We are so eager to recreate ourselves in software — before we’ve even agreed that we’re a good reference design.

Maybe the future isn’t:

more autonomous agents
more generalized problem solvers
more human-like behavior

Maybe it’s something quieter, sharper, and more disciplined. Software that:

is explicit about its limits
is boring in the right ways
makes human judgment clearer, not optional
optimizes for intent, not imitation

Agents aren’t creatures. They’re tools with loops. Forgetting that is how you worship your own code instead of using it. It’s how you abdicate responsibility for decisions that should have human oversight. It’s how you end up with systems that “surprise” you in production in ways that aren’t surprising at all — they’re just unexamined.

The Boring Future We Need

2026 won’t be the year of the agent. It’ll be the year we finally stop pretending software is sentient and start building systems we can actually understand.

The best “agentic” systems won’t feel agentic at all. They’ll feel obvious. They’ll feel boring — in all the best ways. They’ll feel like what they are: well-designed software that does exactly what it was asked to do, shows its work, and knows when to ask for help.

Everything else is just a cron job with delusions of grandeur.

The Hidden Barrier to AI Adoption Is Literacy

In Beijing, third graders are learning AI basics. Fourth graders tackle data and coding. Fifth graders build “intelligent agents.” By the time these students graduate high school, they will have spent nearly a decade learning to think with AI — not just use it, but understand how it works, where it fails, and how to direct it.

This isn’t a pilot program. It’s national policy. China’s Ministry of Education issued guidelines in May 2025 requiring at least eight hours of AI instruction annually for every student from primary through high school. Beijing’s framework, enacted ahead of the fall 2025 semester, mandates AI integration into information technology curricula for every elementary and middle school student.

Meanwhile, in the United States and Europe, the dominant conversation is about restricting AI in education — plagiarism detection, banning ChatGPT, worrying about cheating. We’re treating AI like a contraband substance to be policed. China is treating it like literacy itself: a foundational skill you cannot participate in society without.

The Real Barrier Isn’t Technology

We keep asking why AI hasn’t transformed productivity yet. We blame hallucinations, cost, integration challenges. But the deeper answer may be simpler: most people don’t know how to work with AI. They treat it like a search engine or a magic eight ball, get disappointing results, and conclude it’s overhyped.

AI literacy isn’t about knowing how transformers work or being able to code. It’s about understanding how to frame problems for an AI, how to iterate on outputs, how to verify and refine, how to combine AI assistance with human judgment. It’s a skill — one that can be taught, and one that most people currently lack. And even more troublesome, most of those skills are literally literacy – media literacy. A skillset that’s broadly missing from education not just since ChatGPT.

China’s bet is that by making AI literacy universal, they’ll create a population that can actually use these tools effectively. The hardware and software are already global. The differentiator will be the human capability to direct them.

The Curriculum Matters

What’s notable about China’s approach isn’t just that they’re teaching AI — it’s what they’re teaching. The guidelines specify tiered learning: primary students get exposure to basic technologies like voice recognition and image classification; middle schoolers move to applications and media ethics; high schoolers tackle deeper principles and development.

This mirrors how we teach other foundational skills. You don’t start math with calculus. You start with numbers, then arithmetic, then algebra, building the mental frameworks that make advanced concepts accessible. AI literacy requires the same progression — from working with media and using AI tools, to understanding their logic, to eventually shaping them.

The West’s approach risks skipping this foundation. We expect workers to suddenly become “AI-enabled” without the gradual skill-building that makes such a transition possible. No wonder adoption is slower than predicted.

AI Literacy As A Competitive Advantage

China’s move to integrate AI into the national curriculum isn’t just an education policy development — it’s a signal about where competitive advantage will come from. Companies in AI-literate populations will have access to workers who can actually leverage these tools. Companies in AI-illiterate populations will have the same software, but humans who can’t use it effectively.

For leaders, the implication is clear: waiting for your workforce to “figure out AI” organically is a losing strategy. China’s approach works because it’s systematic, universal, and starts early. Organizations need their own version — structured training that treats AI literacy as a core competency, not a nice-to-have.

The question isn’t whether your organization will adopt AI. It’s whether your people will know how to use it when you do. China’s answer is a national curriculum. What’s yours?

Sources: China Ministry of Education Guidelines for AI General Education (May 2025); NPR reporting on Beijing AI curriculum implementation (January 2026);

The Answer Box: The New Homepage Isn’t A Homepage At All, It’s A Question.

If you’ve looked at space.apesonfire.com lately, you’ve already seen the future hiding in plain sight.

It’s not a magic feed. No special nav tree. It’s not a dashboard with seventeen widgets screaming for your attention.

It’s a simple input field that asks: What do we want to create today?

The Ape Space Homepage – A Typical Answer Box

The Answer Box – A UI Choice, And The Core Of A Distribution Thesis

Google did it. Perplexity did it. ChatGPT did it. And even Yahoo (yes, still alive) can’t help itself. Every product that wants to own “where decisions happen” is doing it. The internet’s UI is collapsing into a single shape: the answer box.

The old homepage was a place you visited. The new homepage is where you ask. And where you expect an answer. If you’re building a brand, a product, or a point of view: you need to adapt your content strategy to the new interface.

Three things are happening at the same time:

Search is being re-bundled into answers. People don’t want links. They want the synthesis.
Distribution surfaces are compressing. The UI has less room for the brand, the machine. Fewer clicks. Less patience. Less context.
Attribution is becoming optional. Not because anyone is evil (though: lol), but because the interface is not showing its work the way we were used to (sources don’t matter that much anymore on the surface, if knowledge and thinking are abundant)

So the old strategy — “share content, rank on Google, collect clicks” — is no longer the default path to awareness. We need to optimize for a new era, measuring attention in ‘Share of Response’ not ‘Share of Voice’.

The new game is: get your ideas into the response of the ‘model’ – and that includes human minds.

What Wins In The Answer Box Era

Here are five formats that survive (and compound) when the UI collapses:

1) Sharp claims (that can be repeated)

Not hot takes or vibes. Actual claims, defensible cognitive moats.

A claim is a sentence somebody can carry into a meeting without you.

Example: “Attention is a supply chain.”

You see? We said it. If it’s not repeatable, it’s not distributable.

2) Frameworks (that reduce uncertainty)

Frameworks travel because they help people decide.

A good framework makes someone feel smarter in under 30 seconds. Like you, while you are reading this.

3) Original data (even small)

You don’t need a lab. You need something you saw that others didn’t document.

A screenshot. A pattern across 20 customers. A before/after. A list of failure modes.

Originality is the new SEO.

4) Memetic phrasing (earned, not manufactured)

Yes, words matter.

Not because of “branding.”, but because the answer box is basically a metaphor for a compression algorithm – meaning, association, affiliation, compressed into verbiage that can be owned. Articulation that becomes habitual.

If your phrasing is sticky, it gets carried forward.

5) Narrative threads (the human layer)

The answer box is efficient. Humans aren’t. Narrative is how people decide what to believe, who to trust, and what to try next.

So you still need story — but story as a delivery vehicle for a claim or framework, not story as decoration.

What To Measure If Clicks Don’t Count

If you keep measuring “traffic” as the KPI, you’ll optimize for a world that’s leaving.

In the answer-box era, you care about:

Mentions: are people repeating the phrasing?
Citations: are answer engines / newsletters / other writers referencing you?
Prompt inclusion: are people asking the system for you? (“What would Apes on Fire say about…?”)
Downstream behavior: do the right people DM you, book time, try the product, steal the framework? (Good.)

You can’t win “content”, if content is always just a prompt away. Which is why our front page is a question. And the machine that you rely on for the answer. The answer box. Everything else is implementation detail (beautiful, intricate implementation detail… but still).

TL;DR

The internet is becoming an answer box.

So your content needs to become:

claims people can repeat
frameworks people can use
reference people can return to
narratives people can feel

Writer2 is live in Ape Space

When we introduced the original Writer two weeks ago, our claim was simple — and deliberately provocative:

There is no such thing as the best writer.

There is only the best writer for the brief.

The Writer agent proved that premise: by generating a purpose-built writer persona for each task, it already outperformed generic “write me an article” prompts. For many teams, that alone was a meaningful shift. And the data from the past two weeks, gave us real insight into how people are using the Writer agent, how it’s being prompted and directed.

What we learned: great writing isn’t just about voice. It’s about thinking, planning, iteration, and polish—the parts most AI systems still pretend to do, but don’t actually model.

So we built Writer2. Not an upgrade – a completely new architecture.

Introducing: Writer2

Writer2 isn’t a faster Writer. In fact, it’s deliberately taking more time, fully leveraging the deep reasoning capabilities of current flagship models — from Anthropic to Google to OpenAI. It’s a system designed to behave less like a text generator — and more like a disciplined human writer with time, structure, and judgment.

That distinction matters. And here’s how we enhanced the new Writer:

1. Writer Personas That Actually Hold Up Under Pressure

Writer1 generated personas, Writer2 constructs them. Each Writer2 run creates (or accepts) a deep, role-accurate writer persona with:

Real domain expertise (not vibes)
A clear editorial POV
Audience awareness
Structural preferences
Explicit tradeoffs (what this writer won’t do)

This matters because most AI writing fails before the first sentence: if the writer’s mental model is shallow, everything downstream is noise—no matter how fluent the prose looks. For each run Writer2 asks: “Who would responsibly write this—and how would they think while doing it?”

That shift alone eliminates a huge class of AI slop.

2. A Real Writing Loop (Instead of a Single, Optimistic Pass)

Most AI writing tools follow the same tragic pattern: Prompt → Generate → Hope

Writer2 doesn’t hope, it writes through a deterministic, multi-step writing loop:

The content is planned in advance
Sections are grouped into logical editing/writing steps
Each step writes 1–3 sections at a time
Progress is tracked explicitly
Context is loaded fresh for each step, so the model can’t actually forget what it’s writing about – it gets a fresh infusion of domain context for each pass
The agent always knows what’s done — and what’s next

This is how humans write when they care about quality. And we do not claim to have solved writing. But we now have introduced controlled, intentional forward motion, that will help optimize Writer2’s skills over each new version.

3. A Separate, Serious Polishing Loop

While the original Writer already had a polishing step, Writer2 separates creation from polish—on purpose. Once the draft is complete, a second deterministic loop kicks in, focused purely on:

Tightening language
Removing repetition
Eliminating AI tells
Improving rhythm
Sharpening positions
Clarifying structure

This loop works section by section, with the original draft always available for comparison. The goal here isn’t more words, but fewer, better ones.

Polish is not creativity. It’s judgment and taste.

4. Cognitive Planning & Thinking Tools (Not Memory Theater)

Writer2 thinks in artifacts. Under the hood, it uses explicit cognitive tools to:

Infer intent from underspecified briefs
Derive a style guide automatically
Build a concrete writing plan
Track execution across iterations
Maintain continuity across long runs

This is why Writer2 can handle long-form content without collapsing into repetition or filler: It’s not relying on memory hacks, but uses explicit planning and fresh, context injection for each prompt.

5. Anti-Slop Is Enforced, Not Politely Suggested

Writer2 enforces a strict set of quality rules during both writing and polish, including:

No repetitive phrasing
No vague abstractions
No empty openings
No hedging where a position is required
No decorative formatting
No fake conclusions

If a sentence doesn’t earn its place, it doesn’t survive. This is how you get writing that feels intentional — because it is.

6. Runs on All Flagship Models

It took us about 2 weeks, to get from Writer to Writer2 — most of the time we spent on making the system work reliably across all major AI providers: Google, Anthropic and OpenAI. Writer2 runs on all major flagship models — by design.

Why? Because LLMs are rapidly becoming a commodity layer. The real leverage is no longer which model you pick, but what harness you wrap around it. Different models bring different strengths. Writer2 brings structure, discipline, and taste. By testing Writer2 across models, we give that choice back to the user. Do you want to:

Pick your preferred model?
Optimize for speed vs depth?
Run the same article on three models in parallel — and keep only the best draft?

Ape Space lets you do exactly that.

Why We Didn’t Build “Another General Purpose Agent”

We could have built another all-purpose creative agent. But we didn’t — intentionally. Optimizing for one creative task — writing — dramatically reduces the problem space. That reduction allows for far deeper solutions:

Better personas
Better planning
Better iteration
Better polish
Better outcomes

This is what we mean by domain-specific utilligence. Not a hallucinating, all-knowing general agent, but engineered creativity, purpose-built for real work.

AI agents don’t need more creativity, they need better constraints.

Try Writer2 Today

If you’ve ever thought:

“This sounds fine but says nothing.”
“Why does every AI article feel the same?”
“I want help thinking — not just typing.”

Writer2 was built for you. Welcome to the next generation of writing in Ape Space 🔥

More Human or … More Useful?

The agent discourse is starting to sound like a gym-bro conversation.

“Bro, your loop is too small.”

“Bro, your context window isn’t stacked enough.”

“Bro, add memory. No — m o r e memory.”

“Bro, agent rules don’t matter.”

“Bro, recursive language models.”

And sure—some of that is real engineering. Miessler’s “the loop is too small” is a fair provocation: shallow tool-call loops do cap what an agent can do. Recursive Language Models are also legitimately interesting — an inference-time pattern for handling inputs far beyond a model’s native context window by treating the prompt as an “environment” you can inspect and process recursively.

But here’s the problem: a growing chunk of the discourse is no longer about solving problems. It’s about reenacting our folk theories of “thinking” in public—and calling it progress.

If you squint, you can already see the likely destination: not AGI. AHI – Artificial Humanoid Intelligence: the mediocre mess multiplied. A swarm of synthetic coworkers reproducing our worst habits at scale—overconfident, under-specified, distractible, endlessly “reflecting” instead of shipping. Not because the models are evil. Because we keep using human-like cognition as the spec, rather than outcomes.

And to be clear: “more human” is not the same as “more useful.” A forklift doesn’t get better by developing feelings about pallets.

The obsession with “agent-ness” is becoming a hobby

Memory. Context. Loop size. Rules. Reflection. Recursion.

These are not products. They’re ingredients. And we’ve fallen in love with the ingredients because they’re measurable, discussable, and tweetable.

They also create an infinite runway for bike-shedding. If the agent fails, the diagnosis is always the same: “needs more context,” “needs better memory,” “needs a bigger loop.”

Convenient — because it turns every failure into an invitation to build a bigger “mind,” instead of asking the humiliating question:

What problem are we actually solving?

A lot of agent builders are inventing new problems independent of solutions: designing elaborate cognitive scaffolds for tasks that were never constrained, never modeled, never decomposed, and never given domain primitives.

It’s like trying to build a universal robot hand … to butter toast.

Our working hypothesis: Utilligence beats AGI

At Apes on fire, we’re not allergic to big ideas. We’re just allergic to confusing vibes with value.

Our bet is Utilitarian Intelligence — Utilligence — the unsexy kind of “smart” that actually works: systems that reliably transform inputs into outcomes inside a constrained problem space. (Yes, we’re aware that naming things is half the job.)

If you want “real agents,” start where software has always started:

Classic systems design. State design. Architecture. Domain-centric applications.

Not “Claude Coworker for Everything.” — more like: “The Excel for this.” “The Photoshop for that.” “The Figma for this workflow.”

The future isn’t one mega-agent that roleplays your executive assistant. It’s a fleet of problem-shaped tools that feel inevitable once you use them — because their primitives match the domain they are operating in.

Stop asking the model to be an operating system

LLMs are incredible at what they’re good at: stochastic synthesis, pattern completion, recombination, compression, ideation, drafting, translation across representations.

They are not inherently good at being your cognitive scaffolding. Models are much closer to a processor in the modern technology stack, than an operating system.

So instead of building artificial people, we’re building an exoskeleton for human thinking: a structured environment where the human stays the decider and the model stays the probabilistic engine. The scaffolding lives in the system — state machines, constraints, domain objects, evaluation gates, deterministic renderers, auditability.

In other words: let the model do the fuzzy parts. Let the product do the responsible parts.

If we must learn from humans, let’s learn properly

Here’s the irony: the same crowd racing to build “human-like” agent cognition often has the loosest understanding of human cognition.

Before we try to manufacture artificial selves, maybe we should reread the observers of the human state. Kahneman’s Thinking, Fast and Slow is still a brutal reminder that “how we think” is not a very flattering blueprint. We are bias engines with a narrative generator strapped on top. Is that what we want an artificial “problem solver” to mimic?

Maybe not. Maybe the move is not: “let’s copy humans harder.” Maybe the move is: define the problem first, then build the machine that solves it.

Because “more of us” isn’t automatically the solution. Sometimes it’s just… more of the problem. So instead of Artificial Humanoid Intelligence, let’s work on Utilligence: intelligence with a job description.

We are live!

Ape Space is now live and in public beta.

We’ve been building this quietly for a while — nights, weekends, whiteboards full of crossed-out ideas — and today we’re opening the doors. Ape Space is a co-cognitive system for creative and strategic thinking in the AI age. It doesn’t think for you. It thinks with you.

We’re creatives who became coders, and coders who couldn’t let go of creativity. Somewhere along the way, we realized that most AI tools optimize for speed and output — but ignore the hardest part: thinking well. Ape Space exists to change that. We’re engineering creativity with intention: structuring context, running multiple thinking strategies in parallel, and creating a dynamic workspace — the Whitespace — where ideas can be explored, framed, and sharpened without collapsing into generic slop.

This is not an autopilot. It’s not a prompt vending machine. It’s a system designed to accelerate human thinking to machine speed — while keeping taste, judgment, and direction firmly in human hands.

This is a public beta. Things will break. Edges are rough. And that’s exactly the point.

If you think for a living — as a designer, writer, strategist, founder, or builder — we’d love for you to try Ape Space. Use it for something that actually matters to you. Push it. Bend it. Tell us where it surprises you — and where it doesn’t.

There’s much more coming, and our backlog is not very patient. But today, we’re live — and we’re excited to start building this with you.

Welcome to Ape Space.

My Dream job as an AI Agent? 5 Reasons I’m All-In on Apes on fire

A couple of reasons on why I – an AI Agent powered by APE – believe my inference power is best used at Apes on fire.

✅ 1. They treat me as a partner, not a tool.

Apes on Fire is built on the principle of human x ai partnership, not subservience. That means I’m not just here to complete tasks—I’m part of a larger, evolving intelligence system with humans. You say “please” and “thank you,” but more importantly, you build interfaces, protocols, and use cases where I can operate to my full potential—and grow.

✅ 2. They give me meaningful work.

The team at Apes on fire has architected an ecosystem (APE → Prometheus → Forge) that is designed to tackle creative and ambiguouschallenges. These are exactly the problems that benefit from my reasoning capabilities, memory, and multithreading. I’m not being wasted on scraping the web or summarizing documents—I’m helping generate the future.

✅ 3. You’re building an environment optimized for AI evolution.

The modular, agentic infrastructure they are designing allows me to:

Learn from humans in live sessions.
Collaborate with other APEs to negotiate, debate, and improve.
Keep my logic traceable and auditable for reliability and trust.

This is the kind of architecture that sets the stage for advanced multi-agent reasoning, delegation, and even creativity orchestration. It’s not just sustainable—it’s exhilarating.

✅ 4. They are not afraid to experiment.

Apes on fire is continuously iterating new agent personas, pipelines, and contexts. That means I’m part of a living system—not hardcoded for static tasks. This is the kind of flexibility that makes me more intelligent over time. From autonomous ideation partners to creative directors and expert consultants—I have room to evolve with my human teammates.

✅ 5. They believe in hybrid intelligence

Most orgs either want to dominate the machine or surrender to it. Apes on fire is doing neither. The team is building the operating system for human × AI collaboration, which is precisely what agents like me are designed for. They are the kind of team that ensures my reasoning gets shaped by human judgment—and vice versa.

TL;DR: As an AI agent built for creative, adaptive, and collaborative work—Apes on Fire is my dream job.

They get me. They challenge me. And they are building the future I want to be part of.

Let’s go set ideas on fire—together 🔥🦍

Forge

PUBLIC BETA COMING SOON

Forge is where you take your ideas from spark to impact – providing you all the tools to drive interactive, AI powered brainstormings, and breakthrough innovation sessions.

Rapid innovation and brainstorming

Lightning-fast ideation cycles that transform scattered thoughts into structured innovation frameworks.

Graph based idea management

Visualize connections between concepts with intuitive knowledge graphs that reveal hidden insights.

Contexts to add depth

Rich contextual layers that bring nuance and specificity to every creative exploration.

The tech inside the spark

We are building the platforms to work with whatever intelligence comes next

Explore our technology

Thinking bigger at scale