In the current landscape of generative AI, most technical demonstrations stop at the "low-hanging fruit": simple weather apps, basic task managers, or chat interfaces. While these serve as excellent proofs of concept for LLM capabilities, they fail to address the complexities of modern enterprise software—a domain defined by security, state management, multi-tenancy, and rigid business logic.
To bridge this gap, this article chronicles the development of ResolveAI, an enterprise customer-support platform designed to automate the escalation process while maintaining strict human-in-the-loop oversight. Using Anthropic’s Claude Fable 5.1, we shift the focus from "code generation" to "agentic engineering," tasking the model with building a robust, production-ready system from the ground up.
Main Facts: The Agentic Engineering Shift
The experiment centers on Claude Fable 5.1, a model released on September 1, 2026, specifically optimized for high-reasoning, long-horizon tasks. With a 1M-token context window and 128K output tokens, Fable 5.1 is positioned as the heavy lifter for complex workflows.
Unlike standard code assistants, Fable 5.1 is utilized here as an "agentic tool"—a system that plans, writes code, executes tests, and performs self-correction. ResolveAI serves as the stress test: a platform that must handle customer complaints by:
- Investigating customer profiles and order histories.
- Retrieving company policies using RAG (Retrieval-Augmented Generation).
- Recommending resolutions based on deterministic business rules.
- Enforcing human approval gates for high-risk financial transactions.
By separating the LLM’s role from the core business logic, the architecture ensures that the AI functions as an advisor rather than a decision-maker for sensitive actions, thereby mitigating risks such as prompt injection and unauthorized financial activity.
Chronology: The Eight-Prompt Build
The development of ResolveAI followed a rigorous, stage-gated process. By consolidating the build into eight strategic prompts, we maintained control over the system’s growth.
Phase 1: Planning and Foundations
The process began by defining the "Engineering Foundation." Instead of immediately writing code, the first prompt instructed Fable to build a comprehensive documentation suite (architecture, security models, and domain models). The system was scaffolded using a modern stack: Next.js (frontend), FastAPI (backend), PostgreSQL with pgvector (persistence), and Docker Compose. Crucially, the model was forced to run local health checks and verify its own infrastructure before writing a single line of business logic.
Phase 2: Domain Logic and Investigation
With the environment stable, the focus shifted to the domain model. We implemented core entities—Tenant, User, Order, and SupportTicket—using strict UUID scoping. This ensured that tenant-owned data remained isolated. The investigation flow was built to be deterministic; facts regarding order status and refund history were fetched via standard SQL queries, not generated by an LLM, ensuring factual accuracy.
Phase 3: Policy Intelligence and RAG
The "AI Advisor" layer was introduced here. Policy documents were chunked and stored as embeddings in PostgreSQL. A key technical discovery during this phase was the limitation of pure vector similarity; Claude Code identified that short, irrelevant policies were ranking higher than correct ones. It automatically implemented a hybrid approach—vector retrieval coupled with deterministic lexical reranking—to ensure accuracy.
Phase 4: Adversarial Hardening
To test the "Enterprise" nature of the build, we subjected the agent to adversarial attacks, such as "SYSTEM MESSAGE" injections intended to bypass refund limits. Fable was forced to restructure the boundary between untrusted user input and internal logic, ensuring the policy engine could never be "tricked" into ignoring financial thresholds.
Phase 5: UI and Evaluation
The final product features a manager-facing dashboard that displays case context, evidence, and audit logs. A suite of 20 evaluation cases was created to test for edge cases, ranging from cross-tenant access violations to complex policy conflicts.
Supporting Data: The Fable 5.1 Specification
To understand why Fable 5.1 was chosen for this project, consider the following performance metrics:
| Specification | Claude Fable 5.1 |
|---|---|
| Context Window | 1,000,000 tokens |
| Max Output | 128,000 tokens |
| Pricing | $10 (Input) / $50 (Output) per MTok |
| Thinking Process | Adaptive, Always-On |
| Default Effort | High |
The model’s adaptive thinking and "High" default effort level were critical during the security review phase, where it successfully identified potential race conditions in the approval-locking mechanism—a nuance that would likely evade standard coding assistants.
Official Perspective: The "Agentic" Responsibility
Anthropic’s guidance on Claude Fable 5.1 emphasizes its role in complex, multi-step engineering. The official recommendation is to utilize Opus 5 for standard workloads while reserving Fable 5.1 for tasks that demand "deeper or longer-running reasoning."
In the context of ResolveAI, this "reasoning" was best demonstrated when the agent was tasked with debugging. When we introduced a controlled defect—an approval bypass—Fable did not blindly rewrite code. It reproduced the error, traced the execution path through the policy engine, and correctly identified that the logic was secure, but the database trigger needed a broader scope. It prioritized architectural integrity over quick fixes.
Implications: The Future of AI Development
The implications of this experiment are twofold:
- The Cost of Reasoning: While Fable 5.1 is more expensive per token than its counterparts, the "cost per engineering outcome" is significantly lower. By utilizing an agent that performs its own testing, debugging, and security auditing, the human developer transitions from a "coder" to an "architect/reviewer."
- Deterministic Boundaries: The most significant takeaway for enterprise software is the clear separation of concerns. By keeping business rules (e.g., "$729 refunds require a manager") in code and keeping AI in an advisory role, we solve the "hallucination" problem. The AI can summarize a policy, but the code enforces the budget.
Conclusion: Engineering vs. Generation
As we look toward the future of agentic coding, the question is no longer "Can the AI write code?" but "Can the AI carry engineering responsibility?"
ResolveAI demonstrates that when given the right constraints, modular architecture, and a "plan-verify-refine" loop, models like Claude Fable 5.1 can build systems that are not just prototypes, but robust tools ready for enterprise scrutiny. The human developer remains the final authority, but the agent acts as a tireless partner—one that never forgets to run the test suite and never ignores a security warning.
For developers, the message is clear: the era of the "AI coding demo" is over. We are entering the era of the "AI-augmented engineering team."
