Ignite Bold Ideas, Faster

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

↓

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.

A Better Writer – For Every Brief

Most AI writing tools try to impress you. They promise speed. Volume. Infinite drafts. They spray words onto the page and call it creativity.

We didn’t build that.

The ‘Writer’ agent in Ape Space is a disciplined expressive writing engine. Nothing more. Nothing less.

It exists for one simple reason: to help you say exactly what you mean — with clarity, intention, and style — without losing the thread of what you’re actually trying to build.

Not louder writing, not more writing. Better writing.

Writing is not typing

Here’s a quiet truth most tools ignore: Writing is thinking under constraint. Good writing doesn’t start with words. It starts with context, intention, and tension. That’s why the Writer in Ape Space doesn’t behave like a chat prompt with autocomplete. It behaves like a system — one that respects how real writers actually work.

Under the hood, Writer is an agent system: a small, disciplined ensemble of sub-agents, each with a clear job, designed to stay deterministic, inspectable, and steerable. No vibes, no black boxes. No “hope this prompt works.”

Here’s how it works:

No worries … HERE is how it actually works.

1. Any prompt. Any format. No drama.

You start with:

A prompt (rough, sharp, or half-formed)
A desired output format — essay, memo, poem, manifesto, viral post, strategy doc, screenplay fragment

That’s it. No magic incantations. No prompt gymnastics.

Writer doesn’t assume you know how to ask. It assumes you know what you’re trying to express, even if it’s still fuzzy.

2. The ideal writer persona (built fresh, every time)

Before a single sentence is written, Writer creates an ideal writer persona, purpose-built for this task, this whitespace, this moment. Not a generic “great author.”

Instead, the system asks:

What is being built here?
Who is this for?
What tone serves the intention?
What should be avoided?
What kind of writer would actually succeed at this?

The result is a writer optimized for your context, not our defaults. Different whitespace → distinct writer. For every prompt.

3. The writer plans before it writes

Real writers don’t just type. They plan — even if subconsciously.

So does Writer.

Before drafting, the writer persona:

Outlines an approach
Identifies structural moves
Decides where to build tension and where to release it
Chooses a pacing strategy

This plan isn’t hidden. It’s explicit and intentional. Writing without a plan is how you get word salad.

We’re not into that.

4. Iterative writing with built-in self-critique

Now the writing begins — but not in one big dump.

Writer works iteratively:

Drafting a section
Critiquing it against the original intent
Improving clarity, precision, and rhythm
Checking for drift, fluff, or contradiction

Each pass tightens the work. This isn’t one giant “regenerate until it sounds good” loop. As you can see in the schematics, we tried to build more of a controlled refinement approach.

The writer is allowed — encouraged even — to disagree with itself. The difference is a huge uptick in writing fluency. The model constantly looking at its own output and critiquing it against a stable set of priorities. That’s where quality comes from.

5. You stay in the loop

This matters more than people admit. Hence we have built-in human gates at several points along the agent flow. At any point, you can:

Comment
Approve
Push back
Redirect
Say, “yes — but not like that”

Writer treats feedback as a signal, not interruption. You’re not fighting the system. You’re co-directing it.

6. Final polish, guided by human intent

Once you approve the direction, Writer enters its final phase:

Tightening language
Aligning voice
Removing excess
Sharpening edges

The goal isn’t perfection. As with anything you do in a Whites[ace, the goal is to create output that are faithful to what you want.

Good writing feels inevitable. Like it couldn’t have been written any other way. That’s the bar we set to meet.

Agent Systems

Technically, Writer is what we call an agent system. Not because “agents” are trendy, but because separation of concerns is how you keep things controllable:

One component reasons about intent
One constructs the writer persona
One plans
One writes
One ensures coherence
One integrates feedback

Each step is explicit. Each transition is observable. That’s how you get reliability without killing creativity.

This isn’t about productivity

We didn’t build Writer to help you “ship more content.”

We built it for:

Expression
Precision
Voice
Imagination

For poems that don’t embarrass you later, or essays that actually say something. For memos that cut through noise and for posts that don’t feel hollow. For writing that means it.

If you care about language and if you want a machine that thinks with you, not over you, while you think up new poetry, write manifestos, or the next viral hit.

Try it now, in Ape Space.

A blank page never felt so good.

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