The famous American philosopher Smashmouth once sang, “The years start coming and they don’t stop coming.” Reflecting on these words has never felt more relevant than this past week in our unpredictable AI landscape. The early September announcements from AI’s frontier illuminate an evolving narrative, where innovation and competition seem as ceaseless as those proverbial years.

First, Anthropic dropped Fable and Mythos 5.1, setting the bar high for coding and knowledge work. These models promise tremendous advancements: from debugging elusive errors within hedge fund codes to designing potent new drugs with significantly increased accuracy. Then, Meta entered the fray with Muse Spark 1.3, highlighting its incredible capabilities coupled with a value-centric pricing strategy.

Based on content from Fireship

However, it was OpenAI’s GPT-6 Astra that captured imaginations and headlines. President Greg Brockman made the bold claim that Astra represents an Actual General Intelligence (AGI)—a claim many await to see substantiated. The unveiling, shrouded in mystery and technical glitches, left many eager to glimpse what GPT-6 Astra can achieve, despite the coincidental outages experienced by competitors like ChatGPT and others at the time of its announcement.

Astra’s launch coincided with a wave of metaphorical and literal technology breakdowns, fueling speculations about its impact and capabilities. Opinions are divided, and humorous conjectures abound as if Astra’s first act of intelligence was to eliminate its peers.

As the curtains rose again on Astra, OpenAI encouraged us to envisage a model designed for comprehensive real-world applications. Tested in benchmarks designed to mimic human office tasks, Astra outperformed previous models in both speed and accuracy. Its ability to autonomously discover and exploit zero-day vulnerabilities marks a significant stride in AI capabilities.

The early adopters’ feedback tends to the positive, albeit typical of those who steer clear of OpenAI critiques. Demos showcasing Astra recreating detailed digital environments with striking precision highlight its extraordinary spatial awareness and creative potential.

But what does Astra’s emergence mean in the grand scheme of AI development? The Artificial Analysis Intelligence Index positions it parallel with earlier models, hinting at an optimization over a revolutionary leap. Though, as always, beneath the surface, there might be more to comprehend beyond mere benchmark scores.

This unveiling prompts us to reconsider the future landscape of AI solutions. Whether or not Astra is the AGI we’ve speculated remains a matter of debate, but its introduction undeniably propels the technological conversation forward. As researchers, developers, and enthusiasts alike ponder Astra’s real-world implications and philosophical definitions of AGI, there’s no question that we are witnessing a crucial chapter in AI’s narrative.

The journey continues, with anticipation as a constant companion. Prepare for a more detailed exploration soon, as we endeavor to understand where Astra stands in the legacy of AI innovation, amid both skepticism and awe.

Stay current with Fireship for more insights into this evolving story, and if safeguarding your code against the tides of change is crucial, consider exploring CodeRabbit Security.

Discover 7 ways to use dialogue in your story and learn how to make every conversation work harder for your characters and readers.

7 Things Dialogue Can Do In Your Story

Dialogue is a powerful but often underutilised tool in writing. Dialogue lets you move away from narration and it allows you to bring your story to life. In this post, we look at seven things dialogue can do in a story.

Good dialogue does the following:

1. Dialogue Advances The Story 

Dialogue forces the writer to make the characters interact. When characters interact, you create events and scenarios that bring them closer or further away from achieving their story goal. Get your character off the couch by making them do stuff.

Example:
‘We’re out of milk.’

A simple trip to the store can become an opportunity for something to happen:

1. Do they run into an old acquaintance?
2. Is their card declined?
3. Do they get caught up in a robbery?

2. Dialogue Makes You Show 

When we use only narrative to tell our story we give our readers a secondary version of the events. When we use dialogue the story comes to life and the readers experience the events for themselves. Dialogue is one of the easiest ways to move your story from telling to showing.

Example:
Telling:
Jonathan didn’t want to enrol for a business degree.
Showing:
Alison upended the third and final drawer. ‘You have to know where it is. It’s your college acceptance letter. It’s your entire future.’ She rifled through the papers on the desk.
‘I really don’t know, Mom. I haven’t seen it.’ Jonathan didn’t look up. He was putting the finishing touches on his newest drawing. He held the paper up to the light. You could still see the faint outline of the logo that read Harvard Business School, but he darkened the shadow and it disappeared completely. ‘I haven’t seen the letter anywhere. Maybe Dad threw it out when he threw out my sketches.’

3. Dialogue Introduces Conflict

Conflict, whether subtle or overt, is a vital part of fiction, but it doesn’t always have to be physical. Dialogue is a great source of conflict.

Example:
‘You never told me about the invitation.’ He stomped to the fridge. The bottles rattled as he yanked open the door.
Beryl took a deep breath and smoothed her skirt. ‘Yes, I did. I said that we were invited and that I accepted.’
‘Well, this is the first I’m hearing of it.’ The bottles rattled again and he slammed it once more. ‘And we’re not going.’
Beryl gathered her clutch and courage. ‘Well, then I guess this is the last you’ll hear from me.’ And walked out the door.

4. Dialogue Reveals Character

How we speak reveals so much about who we are. Use your characters’ words to show who they are.

Example:
He adjusted his name tag and moved towards the customer. He needed to close at least one deal today. Aron stuck out his hand, hoping the nearest guy wouldn’t crush it. The man was built like a hulk.
‘Aron Bronson, pleased to meet you.’
‘Impossible.’ The man loomed overhead. ‘The Aron Bronson I knew was a snivelling little brat who tattled to the teacher.’
Aron tried not to flinch as the bones in his hand cracked and groaned under the increasing pressure. ‘Jonty?’ he squeaked.

5. Dialogue Reveals The Setting 

When you use dialogue to convey setting it will help you to avoid writing long blocks of description.

Example:
Ally followed the dim pool of light as it bounced down the passage. ‘What is this place?’ She shone the torch into a room crowded with old metal beds.
‘It used to be a psych ward. They closed it down in the sixties.’
Candice sounded so nonchalant, but Ally wasn’t fooled.
‘Why are there handcuffs attached to the beds?’
‘It was a ward for the criminally insane.’

6. Dialogue Gives Information 

We need to share a lot of information with our readers. We also should vary how we present our information. Dialogue is a good tool to do that. 

Without dialogue:
He heard them coming down the passage and prayed they weren’t singing for him, but the dreary rendition of ‘Happy Birthday to You’ limped closer and closer to his desk.

With dialogue:
‘Come on,’ someone hissed, ‘light it.’
Jeff cringed. Please don’t. Please don’t let them be coming here.
‘One, two, three.’ A staged whisper. A whiff of sulphur from the matches and then it began.
‘Haaaaa-ppppp-yyyy Birthdaaaaaaaay, dear Je-ffffffff.’
They sang. He shrunk, but they kept limping closer and closer with that off-key twang.

7. Dialogue Increases The Pace

Sometimes we need to speed up our stories and sometimes we need to slow down. Dialogue speeds up the story. Use it when you need to add a bit of a punch to your scene.

Slower:
The crime scene tape fluttered in the breeze. The detectives approached the crime scene with caution and dodged the press by crossing to the other side of the street. They needed to be careful and could not afford another blunder. They were on thin ice with the captain already.

Faster:
Brett glared at the journalists.
‘Vultures,’ he hissed as he crossed the street.
Don held up the crime scene tape and he ducked under it. The wind tugged at his notebook.
‘Can’t fuck this one up. Not again.’ Brett muttered as he knelt next to the body.
‘Captain will kill us, that’s for sure.’

The Last Word

Dialogue is an amazing tool to enhance your writing. It can move your story forward, reveal character, create conflict, and change the pace of a scene. When you are stuck, or when your scenes seem a little flat, make your characters talk. TOP TIP: Learn to write better dialogue with The Dialogue Workbook.

Image by Agata from Pixabay

by Mia Botha

More posts from Mia:

1. 4 Super Easy Ways To Create Characters For Short Stories
2. How To Show Character Change Without Telling (With Examples)
3. 7 Supporting Character Types Every Writer Should Know
4. The 3 Surprises Every Story Needs
5. A Quick Start Guide To Writing For Children
6. 15 Inspiring Reasons To Start Writing Poetry
7. Worldbuilding: The Ultimate Setting Checklist For Writers
8. Show Don’t Tell: 5 Simple Techniques Every Writer Should Know
9. How To Show & Not Tell In Short Stories
10. A Complete Guide To Writing Prompts & Daily Writing Practice

Top Tip: Sign up for our free daily writing links.

The post 7 Things Dialogue Can Do In Your Story appeared first on Writers Write.

TIL: Using Blender with coding agents on macOS

I've been having fun with Blender in ChatGPT Codex on my Mac recently. Getting it to work with coding agents is really easy: install the full Mac application from blender.org and run a prompt like this:

Use the already install /Applications/Blender to render a scene of a pelican riding a bicycle

In this case I followed that up with these two prompts:

OK add a background and a lot of flair

Then:

OK make it a whole lot better

And got this image, generated using Blender's Python API:

Tags: ai, generative-ai, llms, blender, pelican-riding-a-bicycle, coding-agents, gpt-6-astra

That’s a wrap on this week. I’m ready for a long weekend here in the States, and will be back with a reading list next Tuesday.

[blog] The Incumbents Are Coming. I’m probably in the minority, but I like when staggering leaders roar back into a primary position against the feisty challenger.

[blog] Your Agent Doesn’t Know How to Wait. Huh. I don’t think I’ve come across this idea before. If your agent needs to wait for an operation to finish, make sure you design it correctly. Otherwise, your costs can quickly balloon.

[blog] How to Handle Errors in Go. Whether you’re writing it yourself or asking an AI agent to do it, make sure your code has robust error handling.

[article] Research: How Curveball Questions Can Surface the Insight You’re Looking For. I’ve spent a fair amount of time this year working on asking better questions. I liked this perspective.

[article] How does developer experience shape the way teams use coding agents? From this data, it looks like those with more experience in a project apply more careful use of AI, and with more rigor.

[blog] Stop rebuilding from scratch: cache Docker layers on Cloud Build. These numbers can have a big impact at scale. Great deep dive here.

[blog] Portal by Spotify cut my Claude Code token usage by 90%. Wasting a ton of tokens just having your LLM read files and do I/O tasks? Save the LLM for real reasoning work.

[blog] How to Think About Open Weight Models. Excellent analysis from Steve here. If you’ve only kept a casual eye on the open model space, or even if you’ve paid close attention, you can learn something here.

[article] Twenty Years of jQuery: How a Little Library Rewired Web Development. This was a big deal twenty years ago. My how everything has gotten more complicated since then.

Want to get this update sent to you every day? Subscribe to my RSS feed or subscribe via email below:

Microsoft flagged a phishing campaign last week that exploits a gap in how machines read text. Attackers are slipping invisible Unicode tag characters into email bodies; they don’t render on screen but change the underlying string that software processes.

The company says attackers are already using the technique at scale to bypass spam filters and ML-based classifiers, and the same approach could cause problems for AI systems that regularly ingest text from external sources.

Tag characters split keywords

Security researchers have documented a nearly identical technique targeting LLMs, commonly called “ASCII Smuggling,” which uses Unicode tag characters in the U+E0000 to U+E007F range — code points that exist in the character stream but aren’t displayed by most interfaces.

That gives you two versions of the same text: what a person reads and what software receives.

For example:

Human view:     funding
Under the hood: fun⟨U+E0020⟩ding

In the campaign tracked by Microsoft Defender for Office 365, attackers weren’t using tag characters to smuggle hidden instructions into an AI model. They placed them inside high-signal words associated with financial phishing, such as “funding,” “loan,” and “credit,” so that filters scanning for those terms would no longer find an exact match.

A hunting signature for ASCII Smuggling fired on roughly 21,000 messages the day before the campaign started and the next day, it fired on more than 1.3 million. Then, just two days later, the count passed 2.3 million. The whole time, recipients saw ordinary-looking offers for business loans and credit lines.

Just two days later, the count passed 2.3 million.

Tokenizers parse them differently

NLP systems break text into tokens before processing it, and slipping an unexpected Unicode character into a word can change how those tokens are formed. Researchers have already shown that encoding techniques can hide adversarial content from AI systems, although Microsoft’s campaign uses the trick for a different purpose.

NLP systems break text into tokens before processing it, and slipping an unexpected Unicode character into a word can change how those tokens are formed.

Exactly what happens depends on the tokenizer. Some may ignore the tag character while others split the surrounding text differently, so developers have to test the models they’re actually using rather than assume they’ll all behave the same way.

Running the text through standard Unicode normalization won’t necessarily remove the tags, either. NFC and NFD can clean up different representations of the same character, but they weren’t designed to strip Unicode tag characters, which means those tags can still make it through to the next step.

Agents lack email’s defenses

Email providers have other ways to spot a suspicious message beyond the words it contains, but an AI pipeline may be working with far less information.

That then becomes a problem when agents are pulling in outside text and using it to decide what to do next because those invisible characters buried in the text can change how it gets processed along the way, while also making a hidden prompt injection much harder for someone looking at the original to catch.

Normalize before the model

For applications that have no reason to accept characters in the U+E0000 to U+E007F range, the simplest approach is to remove them before the text reaches the model, although that gets trickier when an application has a legitimate reason to keep them.

In those cases, developers can compare the original text with a version that has the tags removed and look for anything that changed, while also testing the tokenizer their application actually uses to see how it handles the same characters. Whatever gets cleaned should stay that way through the rest of the pipeline, rather than checking one version of the text and then sending the untouched original to the LLM.

The subdivision flag edge case

Stripping every Unicode tag character isn’t always safe because some serve a legitimate purpose. The subdivision flag emojis for England, Scotland and Wales rely on invisible tag-character sequences to render, and Microsoft’s initial hunting signature was broad enough to trip on those flags before the team carved out an explicit exception.

Stripping every Unicode tag character isn’t always safe because some serve a legitimate purpose.

The post Microsoft built a prompt injection detector. Then it caught a phishing campaign instead. appeared first on The New Stack.