What Does “Agentic AI” Actually Mean?
There's a lot of noise around the term "agentic AI" right now. At its core, it means something specific: an AI system that doesn't just respond to a single prompt, but autonomously takes a sequence of actions, makes decisions at each step, uses the outputs of previous steps to inform the next, and works toward a goal rather than just answering a question.
The key properties that distinguish an agentic system from a regular LLM call are:
- Goal-directed behaviour — the system works toward an end state, not just a single response
- Tool use — agents invoke external capabilities (image generation, storage, APIs) to extend what they can do
- Inter-agent communication — outputs from one agent become inputs to another, creating emergent capability beyond any single model
- Self-correction — agents can validate their own outputs and retry or escalate when something doesn't meet the bar
This project — an automated Amazon A+ content generator — was my attempt to build all four of these properties into a real, useful system rather than a toy demo.
The Problem That Made Agentic the Right Approach
Amazon A+ Content is the enhanced product listing format available to brand-registered sellers. Rich imagery, structured modules, comparison charts, brand story sections. Done well it lifts conversion rates measurably. Done poorly it looks like every other listing. Creating it properly requires a copywriter, a designer, knowledge of platform module specs, and someone to source or generate product imagery.
For agencies managing hundreds of ASINs, this is a genuine bottleneck. It's exactly the kind of multi-step, multi-skill workflow that a single LLM call handles poorly — and that a well-designed agentic system handles well.
Designing the Agent Graph
The first design decision in any agentic system is the agent graph — how many agents, what each one is responsible for, and how they depend on each other. Get this wrong and you either end up with agents that are too broad (doing too much, producing mediocre output) or too granular (creating unnecessary coordination overhead).
I settled on 7 agents organised around genuine task boundaries — places where the nature of the work fundamentally changes and a different kind of "thinking" is needed:
1. Content Strategist — the planner
This agent is where agentic reasoning starts. Rather than jumping straight to writing, it first builds a plan: which A+ modules suit this product, what the core messaging angle should be, what tone fits the audience. It reasons about the goal before executing. Every downstream agent receives its output as context.
2. Design System — cross-cutting context
Translates the strategy into visual rules — colour palette, image style, layout density. This agent's output is consumed by both the Image Generator and the Layout Agent, creating consistency across the package without any of those agents needing to independently reason about visual coherence.
3. Copywriter — constrained generation
Writes all text working within explicit constraints: Amazon's character limits per module, the tone defined by the strategist, the audience emphasis. Constrained generation like this is where agentic systems outperform direct prompting — the agent has structured context to work within, not just a vague brief.
4. Icon Generator — tool use
Generates custom SVG icons for feature callout modules. This is a pure tool-use agent: it takes a list of features from the copywriter and produces structured SVG assets. No reasoning required — just precise, constrained execution.
5. Image Generator — multi-modal tool use
Invokes Amazon Titan Image Generator (with a Flux 2.0 adapter available for higher quality) using prompts constructed from the design system output. The agent doesn't write a prompt from scratch — it uses the design rules to compose a structured prompt, ensuring visual consistency across all generated images automatically.
6. Layout Agent — assembly and grounding
Takes all outputs — copy, icons, image S3 URIs — and assembles them into the actual Amazon A+ module JSON format. This agent's job is grounding: translating creative outputs into a specific, constrained schema that the platform will accept.
7. Quality Validator — autonomous self-correction
This is the most "agentic" part of the system. The validator checks the assembled package against Amazon's content guidelines autonomously — no human review required at this stage. It catches prohibited content, competitor mentions, spec violations, and character limit breaches, then returns a structured pass/fail with specific issues. If it fails, the orchestrator can route back to the relevant agent for a retry.
Orchestration: How Agents Communicate
The agents run in a directed graph with partial parallelism, orchestrated via AWS Bedrock AgentCore Runtime:
Content Strategist ──┐
├──► Copywriter ──────┐
Design System ───────┤ ├──► Layout ──► Validator
├──► Icon Generator ──┤
└──► Image Generator ─┘The first two agents run sequentially — their outputs are the shared context that everything else depends on. Once both complete, the middle three run in parallel. This is where agentic systems show their performance advantage: tasks that are logically independent execute concurrently, with the orchestrator managing dependencies rather than forcing a sequential chain.
Each agent receives only the context it needs — not the full conversation history. This is an important agentic design principle: agents should be focused, not omniscient. The Copywriter doesn't need to know how the image prompt was constructed. The Layout Agent doesn't need to know the design rationale. Scoping context per-agent improves output quality and reduces token cost.
AgentCore: What It Gives You
AWS Bedrock AgentCore Runtime is the infrastructure layer that hosts the orchestrator. It handles the things that are genuinely hard to build yourself in an agentic system:
- Session isolation — each workflow run gets its own isolated session, preventing state leakage between concurrent executions
- Container lifecycle management — agents run in containers, AgentCore handles health checks, restarts, and routing
- HTTP protocol — standardised
/pingand/invocationsendpoints mean the runtime is callable from any client, including Bedrock Agent itself
The practical result: I can focus on agent logic rather than infrastructure plumbing. The orchestrator is a TypeScript Express server; AgentCore handles everything around it.
Real-Time Observability
One of the underappreciated challenges in agentic systems is observability. When something goes wrong in a 7-step pipeline, you need to know which agent failed, what it received as input, and what it produced. Black-box pipelines are a nightmare to debug.
The orchestrator emits structured progress events at each agent transition — agent
name, status, progress percentage, timestamp. These stream to the React frontend via
WebSocket, where a WorkflowTimeline component visualises the pipeline
in real time. In production this same event stream feeds CloudWatch, giving you a
full audit trail of every run.
The Economics of Agentic Systems
One concern with multi-agent systems is cost — more LLM calls means more tokens. In practice, the opposite is often true when agents are well-scoped. A full 7-agent run costs approximately $0.15–0.25 with Claude Sonnet 4.5 and Titan Image Generator. Text generation across all five text agents is under $0.05 total, because each agent's context window is small and focused rather than carrying the entire conversation history.
Compare that to a single-agent approach that tries to do everything in one prompt: the context would be enormous, the output quality lower, and the cost potentially higher. Specialisation wins economically as well as qualitatively.
Key Lessons on Agentic Design
- Design for task boundaries, not model capabilities. The right number of agents is determined by where the work genuinely changes in nature — not by what a single model can technically do in one shot.
- Self-correction is what separates agentic from automated. The Quality Validator turning a pass/fail into a retry loop is the moment the system stops being a pipeline and starts being an agent. Without it, you have automation; with it, you have agency.
- Context scoping is a first-class design concern. Every agent should receive exactly the context it needs. Passing the full conversation history to every agent inflates cost and dilutes focus.
- Observability can't be an afterthought. In a 7-step pipeline, debugging without structured event emission is nearly impossible. Build the event stream before you build the agents.
- Parallelism is free when dependencies are explicit. Once you've drawn the dependency graph, independent nodes can run concurrently with no additional effort — the orchestrator handles scheduling.
What's Next
- Add a reflection loop — let the Validator feed specific failures back to the responsible agent for targeted retry rather than full re-run.
- Introduce a human-in-the-loop checkpoint after copy generation, before layout assembly.
- Connect to Seller Central API to push approved content automatically, completing the full agentic loop from brief to live listing.
- Explore giving agents access to search tools so the Content Strategist can research competitor listings before planning.
Source code: github.com/omishagupta/amazon-aplus-content-generator