GPT-6 Astra’s Higgsfield Integration With After Effects: Our Honest Review & Results

Like many of you, I’ve recently played around with OpenAI’s GPT-6 Astra.

Naturally, as a motion graphics designer, I was interested in taking GPT-6 Astra’s Higgsfield integration with After Effects for a spin.

I know what you’re probably thinking…

Does this spell the end for my profession?

Nope. We’ve had some time to test this internally at Motion The Agency and here’s what we found:

• Astra rebuilt a flat UI screenshot as editable After Effects vectors.
• Unaided, it turned a storyboard into a full animation.
• Unfortunately, it broke on UI shown in perspective.
• Astra followed five rounds of feedback to finish a web animation.
• Every test had flat, one-element-at-a-time motion with weak easing.
• Each iteration took around 15 to 20 minutes to complete.
• This used up over 90% of our $20 plan’s five-hour limit.

As you can see, that’s a mixed bag.

Our team is always busy working in After Effects, so with that in mind, it obviously makes sense for us to properly test anything that claims to work inside the software.

Just last year with After Effects, we produced more than 500 motion graphics videos for clients. 

Giving it a shot, we ran Astra through three projects in an attempt to answer whether or not it's up to scratch.

Before I get into what we tested and how it turned out, let's just take a quick step back and briefly go over what GPT-6 Astra is and how we got here.

What is GPT-6 Astra?

In the GPT-6 lineup, GPT-6 Astra is OpenAI's highest capability model.

The range runs from Luna at the entry level up to Astra at the top.

As you've probably seen on X and LinkedIn, most early reviews are super positive.

Although I think it's probably worth noting that many of those reviews come from people with early access who are not necessarily paying users.

So I guess it makes sense to take those with a grain of salt. 

Scrolling through X, you’ll know that Astra is generally being used for end-to-end workflows and that’s what OpenAI built it for.

After playing around with Astra for a few tasks outside of motion graphics design, including coding and research, I’ve come to think of it as behaving like a pretty advanced intern who can take a job from the first step to a finished result…

Just as long as someone checks the work along the way.

Oh, and you do have to feed it properly… credits, that is.

Astra isn’t shy when it comes to eating up credits.

OpenAI knows this is their best-performing model and you’re expected to pay accordingly.

Personally, I don’t mind a model like Astra with a big appetite as long as it's delivering the goods.

Does it? Well let’s get into that…

Here’s how we tested GPT-6 Astra’s Higgsfield integration…

For us, these tests were really about figuring out whether Astra could make our creative workflows faster or better in any way.

We're always looking for an edge, and if we see a new tool that can potentially get us better results for our clients, we're at least curious about it.

So two of our motion designers, Pujita and Wira, decided to build three tests around different stages of a real project that we've been working on as a team.

These tests range from early visual development right the way through to production and revision. Each piece ran 10 to 15 seconds.

Let me quickly build some context for you:

• Every test involved GPT-6 Astra (Light) on the $20/month ChatGPT plan.
• We used the Higgsfield MCP connector and its use-after-effects workflow.
• No Higgsfield credits used. ChatGPT built everything as native After Effects layers.
• We used a real After Effects project with shapes, text, precomps and editable keyframes.

The last point is incredibly important because a layered project file lets an animator step in and finish the job themselves.

They need the freedom to make clinical edits at the end of a project.

If it's just a rendered MP4, a flat video like that creates a dead end and a whole load of issues when a client inevitably asks for changes.

Realistically, you would be looking at starting again from scratch.

Test 1 - rebuilding a UI shot from a JPEG

We wanted to kick things off with a really common early-production headache that often frustrates designers…

I’m talking about assets that aren’t ready to animate.

This usually happens when clients send over a screenshot or a flattened export instead of source files.

So we went ahead and gave Astra a single JPEG of a UI shot for Blee: a "For Review" deal card (B2B, Seed round) with Pass and Initiate Diligence buttons, a cursor, a profile badge and the headline "So we can focus on the opportunities that matter."

Step 1 - Rebuild it as vectors

The first thing that we needed it to do was rebuild the shot with native After Effects tools and have a separate comp for an empty profile picture.

If we're honest, it went about this in the right way, and we ended up with something that was a lot better than what we had expected.

We found that the card, labels, buttons, and gradient bars all came back as native shape and text layers.

Astra then picked installed fonts (PP Editorial New and PP Mondwest for the headline) that suited the reference.

It then set up a 10-second, 30fps comp and split the profile badge and picture into their own comps as we asked.

As you can see, the copy wasn’t pixel-perfect by any means, but it was close enough to save when we need high-res UI screens for samples.

In total, it was 17 minutes and 42 seconds of work, which left Pujita with just 3% of the five-hour limit left on the ChatGPT plan.

Step 2 -animate it

The second part of this was to import proper vectors through AEUX and ask Astra to animate the shot in our usual way…

We wanted the card to pop up with its contents animated one by one.

The headline would then reveal and the cursor would slide in to click Initiate Diligence, all with eased curves.

We weren’t all that impressed with the first version, which was flat and far too slow for what we were looking for.

Our only round of feedback was words to the effect of…

Animate the text word by word, and add curves so it feels less linear.

Unfortunately, because of the usage limit, we could only fit in two prompts.

But luckily, the second version had clearly better timing and easing, so we were ultimately satisfied.

Result

The vector rebuild was the best surprise of the whole experiment.

While the animation made a usable starting point, the layer setup was a tad messy.

To animate text word by word, Astra gave every word its own layer and precomp instead of using After Effects text animators.

And even though it looks perfectly fine on screen, when the animator has to adjust timings later, they’ll have no choice but to open a dozen precomps to change what should be one property.

Test 2 - the storyboard handoff

We used the second test to mirror how a client project typically starts for us at Motion.

Our projects move from a free sample onto storyboard planning before production.

So a storyboard is the most natural brief (and perfect challenge) we could hand an AI.

We gave Astra the Rise Works sample: a seven-frame storyboard (logo intro, dashboard screens, floating UI cards, a globe scene and a logo outro) plus the high-resolution shots from Figma.

There were no editable vectors, so we told it to animate everything in After Effects and use GPT Image where required and to spend no Higgsfield credits.

We then mostly left it alone.

Result

This was the most hands-off result of the three tests.

End to end, Astra built us a full sequence without any extra direction.

You could see it working hard to rebuild each UI screen.

Frustratingly, anything shown at an angle or in 3D space came out wrong.

Shots 2 to 5 all place UI in perspective and none match the reference.

It seems as though perspective is its weak point.

And we noticed the timing had the same sequential problem we saw in the first test.

The output is usable and a client can see the flow and rough pacing of their storyboard, but as a final deliverable, it's not something that our team would feel comfortable sending.

Test 3 - five rounds of feedback

This final test was all about treating Astra as if it were an animator on our team receiving ongoing creative direction.

Version 1:

For the input, we used a brand overview and creative brief for Journey Horizon as a markdown file, along with one line: create a short motion visual for Journey Horizon in After Effects.

From there, we went on to give five rounds of plain-English notes:

Version 5:

This was the test that our team was the most impressed by because Astra followed layout, timing, camera and styling notes round after round.

It was great to see that Astra kept earlier changes intact and added music and sound effects when asked.

The motion still moved one thing at a time and the finished piece works well as a web animation or interactive collateral.

One problem showed up across all three tests

Astra animates sequentially, and this is a problem that came across all three of our tests.

This meant that one element finished before the next one started, and we know that good motion design often relies on overlap.

When a card slides in, its content starts appearing before it settles.

In the same way, a headline begins its reveal while the cursor is still traveling.

This is how you make a piece feel layered and alive.

It's all about creating depth and that's what the offsets of a few frames do.

Easing was also an issue.

Even when we asked for curves directly, the motion stayed close to linear.

Ultimately, overlap and easing are judgment calls for a designer and that’s hard to put into a prompt.

It’s as much about taste as anything else, because you can ask for “more overlap” from an animator, but they’ll need to decide how much, on which layers, by watching it back.

I don’t think Astra has really learned that part of the job yet.

We tried recreating it ourselves — here’s what happened…

If you’re even a little familiar with our work, you’ll probably know that we don’t shy away from saying we use AI in our workflow.

But there’s one rule we stick to: we only use it when it actually makes the work better or faster.

So alongside all of these tests, we wanted to answer one more question…

Could one of our animators recreate Astra’s output in the same amount of time, using the same assets, and get a better result?

For the first test, Astra’s 10-second video used almost the full five-hour limit on our plan. So we gave the same assets to Dano, one of our motion designers, and asked him to rebuild the piece within roughly the same five-hour window.

The idea was pretty simple: same brief, same assets, same amount of time.

Then we compared the results.

AI result:

Human result:

At first glance, the difference probably isn’t huge.

But once you watch the motion closely, you can definitely see it.

Astra still falls into the same problem we noticed throughout our tests: everything happens quite sequentially. One element moves, then the next one starts, which makes the animation feel a little flat and mechanical.

Dano’s version has more overlap between movements. Elements start moving before others have completely settled, timings are offset, and the whole sequence feels more fluid and connected.

It’s a small difference on paper, but it makes a big difference to how polished the final animation feels.

So yes, Astra did a pretty good job.

But this comparison also reinforced what we found throughout the rest of the test: the human touch is still doing a lot of the heavy lifting when it comes to timing, easing, overlap, and knowing when something simply feels right.

So, is GPT-6 Astra worth using?

I’d say yes — but only if you have the right person behind it.

Used as a support tool, it can absolutely save time and give an animator a useful starting point. But if you’re expecting it to replace the judgment that goes into polished motion design, I don’t think it’s there yet

You should bear speed & usage limits in mind

Astra was pretty slow at producing these rough cuts, especially as they still need an animator to go in and fix the motion.

We found that each iteration took around 15 to 20 minutes for Astra to complete, and that was for a 10 to 15 second animation.

On top of that, usage was a big blocker because on the $20 plan, every workflow took the five-hour Astra limit from 100% to under 10%.

Interestingly, Pujita and Wira found that one off-peak round used up less than half of the allowance while four peak-hour rounds used nearly all of it.

Hard stops when the limit runs out are very frustrating when you’re up against the clock trying to meet a client deadline.

Does Astra really fit in a motion workflow?

Final client videos stay with our animators because the work we make for ClickUp, HackerRank, Attio, and other companies depends on the overlap, easing and clean project structure Astra is still missing.

For these reasons, I think GPT-6 Astra works best as a support tool.

Maybe future models from OpenAI will prove more capable.

Sequential timing, near-linear curves, messy comps and broken perspective all need an animator to fix.

The somewhat unpredictable speed and usage limits also make it hard to rely on under a tight deadline.

Want motion that already has the overlap? Request a free sample and our team will deliver a video within 48 hours.

FAQ