Tom Neijman

Posted on Jan 18

Prompt Engineering is becoming obsolete!

Rator Framework: The Architecture of Agentic AI

Prompt Engineering is becoming obsolete. It's time for Context Architecture.

We've spent the last two years obsessing over how to talk to AI models. Endless prompt templates, magical incantations, and "just add 'think step by step'" advice. But in 2026, the bottleneck isn't the prompt anymore.

It's the pipeline.

While building advanced Agentic Workflows, I realized we're missing a standard vocabulary for the two biggest points of failure in any AI system. So I'm introducing The Rator Framework — a simple mental model (and architectural pattern) for building reliable Multi-Agent Systems.

The Core Axiom

In modern software development, AI performance is not defined by the model's intelligence, but by the alignment of information and intent.

We can identify two fundamental failure modes in Agentic Systems:

1. The Knowledge Gap (Prompt without Context)

Symptom: The Execution Agent understands the question but misses the background.

Result: Hallucination. The model guesses variable names, architectural patterns, or dependencies that do not exist.

You've seen this: you ask an AI to refactor a module, and it invents function names that aren't in your codebase. It's not stupid — it just doesn't know.

2. The Instruction Gap (Context without Prompt)

Symptom: The Execution Agent has all the information but lacks specific direction.

Result: Passivity. The model explains the code instead of fixing it, or produces generic solutions that ignore project-specific constraints.

You've seen this too: you dump your entire repo into the context window, ask for "improvements," and get a Wikipedia article about best practices instead of a working patch.

The Formula

To solve this, we must stop treating prompts and context as additive features. They are multiplicative factors.

Success = Contextrator(Relevance) × Promptrator(Instruction)

Think about what this means:

If Relevance is low (noise, wrong files), the result is zero.
If Instruction is low (vague intent), the result is zero.
You cannot compensate for a lack of context by writing a better prompt, and vice versa.

This is why your perfectly crafted prompt still fails when the context is garbage. And why a rich context still produces mush when the instruction is "make it better."

The Roles

To satisfy the formula, we introduce two distinct architectural layers between the Orchestrator (the intent source) and the Execution Agent (the LLM).

1. The Contextrator

/kɒnˈtɛkstreɪtər/ — noun

An AI agent or logic layer responsible for curating the "Knowledge State."

Mission: Solves The Knowledge Gap.

Function: It filters the noise. It determines exactly which files, documentation, and history are relevant for the current task — and, crucially, excludes everything else.

Motto: "Relevance over Volume."

The Contextrator doesn't solve the problem. It doesn't write code. It answers one question: "What does the Execution Agent need to know?"

In practice, this might be:

A retrieval system that selects relevant files from a codebase
A logic layer that pulls in the right documentation
An agent that queries your knowledge base and filters results

2. The Promptrator

/ˈprɒmptreɪtər/ — noun

An AI agent or logic layer responsible for translating intent into execution constraints.

Mission: Solves The Instruction Gap.

Function: It converts a high-level intent (e.g., "Make this robust") into explicit system constraints (e.g., "Use TDD, adhere to SOLID principles, implement error handling via custom exceptions").

Motto: "Intent is not Instruction."

The Promptrator doesn't gather information. It doesn't decide what's relevant. It answers one question: "How exactly should the Execution Agent behave?"

In practice, this might be:

A template system that enforces coding standards
An agent that expands vague requests into specific constraints
A rule engine that applies project-specific guidelines

The Flow

Here's how the Rator Framework operates in a production pipeline:

1. Orchestrator: "Refactor the auth-module to use OAuth2."
   (Source: Human, CI/CD Trigger, or Product Owner Agent)
                    │
                    ▼
2. Contextrator: "Scanning repo... Loading auth.py, user_schema.py, 
   and oauth_config.json. Ignoring frontend assets."
                    │
                    ▼
3. Promptrator: "Role: Senior Architect. Constraint: Maintain backward 
   compatibility. Pattern: Adapter Pattern. Output: Code only."
                    │
                    ▼
4. Execution Agent: Generates the perfect patch.

Each layer has a single responsibility:

Orchestrator → What needs to happen
Contextrator → What information is needed
Promptrator → How it should be done
Execution Agent → Does the work

Why This Matters

As we move from simple chatbots to complex Multi-Agent Systems, we need a shared vocabulary. We need to stop conflating "prompt engineering" with "context management" — they are fundamentally different skills.

The Rator Framework gives us:

A diagnostic tool: When your AI fails, ask: Was it a Knowledge Gap or an Instruction Gap?
An architectural pattern: Design your systems with explicit Contextrator and Promptrator layers.
A common language: Teams can now discuss "contextration" and "promptration" as distinct concerns.

Try It Yourself

Next time you're building an agentic workflow, ask yourself:

Is my Contextrator doing its job? Am I feeding relevant information, or just dumping everything?
Is my Promptrator doing its job? Am I giving specific instructions, or just vague intent?

If either answer is "no," you've found your bug.

What's Next?

I'm working on concrete implementations of the Rator Framework for different use cases. If you're interested in:

Reference architectures for coding agents
Contextrator patterns for different repo sizes
Promptrator templates for common tasks

Let me know in the comments. And if you're already building something similar, I'd love to hear how you're solving these problems.

Are you focusing enough on your "Contextration," or are you still just prompting?

Find me on LinkedIn for more on Agentic AI architecture.

Tags: #ai #agenticai #llm #softwarearchitecture #devops #promptengineering

DEV Community