Self‑Improving Document Processing with Amazon Bedrock AgentCore: What Works and What Doesn’t

According to Artificial Intelligence, Amazon Bedrock AgentCore can turn a classic rule‑based document pipeline into a self‑learning system that classifies, extracts, validates and improves on its own. For teams that spend a chunk of their day wrestling with invoices, purchase orders or insurance claims, the promise of "process new document types without manual template configuration" sounds like a productivity win – if the technology lives up to the demo.

The hidden cost of template rigidity

Traditional intelligent document processing (IDP) tools rely on a hand‑crafted template for each vendor. When a supplier tweaks a layout, the extraction rules break and a human has to rebuild the template. IDC estimates that document‑related challenges cost $19,732 per information worker each year and shave 21.3 % off productivity. In practice, staff end up spending up to 30 % of their time on data‑entry chores, and manual error rates hover between 1 % and 4 %.

The three pain points are easy to spot:

1. Template rigidity – every new format means a new configuration.
2. No learning – the system forgets corrections after each run.
3. Scaling burden – hundreds of suppliers multiply the maintenance workload.

If you’ve ever watched a rule‑based pipeline choke on a slightly shifted logo or a reordered table, you’ll recognize these symptoms.

Agentic IDP in practice: a quick architecture tour

AgentCore replaces static templates with a fleet of specialised agents that talk to each other over a graph‑based workflow. The core components are:

• Analyzer – pulls raw text with Amazon Textract and tags the document type.
• Matcher – searches a vector store (S3 Vectors) for previously seen layouts.
• Instructions – builds a prompt that tells the Extractor what fields to pull.
• Extractor – runs the prompt against a foundation model (e.g., Anthropic Claude) to produce JSON.
• Validator – checks the JSON against a schema stored in Amazon Aurora DSQL.
• Fixer / Troubleshooter – rewrites the prompt or patches the data when validation fails.
• Save Instructions – persists the refined prompt for future runs.

Two workflows emerge:

• Training workflow – triggered when the Matcher finds no close match. The system generates prompts, validates, fixes and finally stores the new instructions.
• Automation workflow – used for known document types; the Extractor skips prompt creation and applies the saved instructions directly.

All agents run inside the Bedrock AgentCore runtime, are authorised via machine‑to‑machine credentials, and report health metrics to CloudWatch.

Numbers on speed, cost and accuracy

The blog post measured two runs on a sample purchase order from a new vendor, Two Wheel Store:

The speed‑up comes from re‑using the saved prompt; the first run also exposed a SKU‑format mismatch that the Fixer corrected. Accuracy improves because each failure adds a rule to the prompt, so later documents of the same type rarely need a second pass.

Cost estimation for a modest workload (10 training docs + 1,000 processed docs per month in US‑East) lands at about $58 per month, with roughly 85 % of that bill coming from foundation‑model inference (~$0.055 per document). The price tag is low, but it scales linearly with model choice – swapping Claude for a larger model can double the per‑document cost.

Trade‑off spotlight: flexibility versus hidden model expense

The headline benefit is obvious – you no longer maintain a library of brittle templates. The hidden trade‑off is the ongoing inference spend. Each document still triggers a call to a large language model, and the model’s size dictates latency and cost. In environments where volume is high (tens of thousands of invoices a day), the per‑document $0.055 can become a noticeable line item. Moreover, the system’s quality hinges on the model’s ability to follow the dynamically generated prompt; if the model drifts or the prompt becomes too complex, validation failures will rise again.

What you should watch:

• Model selection – start with the smallest model that meets your validation threshold; you can switch models in the config.py without redeploying the whole stack.
• Prompt bloat – each Fixer iteration adds rules to the prompt. Over time the prompt can become unwieldy, increasing token usage and slowing inference.
• Observability gaps – while AgentCore ships with CloudWatch metrics, you still need to surface per‑document error rates to catch regressions early.

In short, the flexibility gain is real, but it trades static‑template cost for a variable, model‑driven cost that requires active monitoring.

Try it yourself: a 30‑minute starter kit

If you have an AWS account and a modest set of PDFs to test, you can get a working pipeline today:

1. Clone the repo – git clone https://github.com/aws-samples/agenticidp-guidance.git.
2. Set up the environment – create a Python venv, install the requirements and the UI dependencies (Node 18, npm).
3. Deploy – run uv run deploy.py --admin-email you@example.com. The script launches six CloudFormation stacks; watch for CREATE_COMPLETE status.
4. Upload a test document – sign into the generated CloudFront URL, choose Process Document, and upload any invoice PDF.
5. Inspect the output – the Review Jobs tab shows the extracted JSON, validation messages and the stored prompt.
6. Iterate – deliberately change a field (e.g., rename a column) and re‑upload to see the Fixer in action.

Because the solution is serverless, you only pay for the Lambda invocations and model calls you actually use. The $58/month estimate assumes the default Claude model; you can edit agents/orchestratorgraph/utils/config.py to point to a cheaper model like Amazon Titan‑lite and cut the per‑document cost roughly in half.

Bottom line for the desk‑bound practitioner

Amazon Bedrock AgentCore demonstrates that a modest amount of engineering can turn a brittle IDP pipeline into a self‑improving workflow. The real win is the reduction in manual template upkeep and the measurable speed gain after the first document of a new type. However, the model‑inference bill and prompt growth are concrete downsides that scale with volume. If you process a few hundred documents a month, the pay‑as‑you‑go price is negligible; once you cross the tens‑of‑thousands mark, you’ll need a cost‑monitoring plan and a disciplined prompt‑pruning strategy.

Action step: Deploy the sample stack, run a single new invoice through the training workflow, and note the per‑document cost in the CloudWatch billing view. Use that data to decide whether a larger model is justified or if a cheaper alternative can meet your accuracy target.

Sources

• Build self‑improving document processing using Amazon Bedrock AgentCore