বাংলা

Five-stage roadmap

AI Engineering

Prompt engineering, RAG, workflows, agent loops and runtimes are not the same thing. Learn their order, then build one measurable system.

See the concept orderCareer overview

Capabilities before buzzwords

From one prompt to a dependable agentic system

These terms do not belong at the same level. Begin with a measurable problem and baseline, add context and workflow, then introduce agency only when real ambiguity requires it.

  1. 1 · Frame the work

    Define the user, outcome, inputs, constraints, risks and evidence of done before choosing a model.

    Build evidence: Write a one-page specification and the smallest deterministic baseline. This is forward engineering: move from an explicit need toward design, implementation and tests.

    • Forward engineering
    • baseline
    • success criteria

  2. 2 · Make one model call testable

    Treat instructions, examples, context and output schema as an interface—not a collection of magic words.

    Build evidence: Create labelled success, refusal and failure cases; compare prompt versions against all of them.

    • Prompt engineering
    • structured output
    • evaluation set

  3. 3 · Ground with evidence

    Use retrieval when the answer depends on owned, current or domain-specific material; retrieval and generation are separate systems to test.

    Build evidence: Start with a keyword baseline, then add chunking, semantic retrieval, source display and refusal when evidence is missing.

    • RAG
    • embeddings
    • retrieval
    • citations

  4. 4 · Orchestrate a visible workflow

    Keep known steps deterministic: trigger, validate, retrieve, call, transform, approve, act and log.

    Build evidence: Implement the same small workflow in code or a visual tool such as n8n. Test retries, timeouts, duplicate events and partial failure.

    • AI workflow
    • n8n
    • orchestration
    • idempotency

  5. 5 · Add bounded agency

    Use an agent only when the model must choose the next step or tool under ambiguity; a fixed workflow is often enough.

    Build evidence: Build one loop: observe context → decide → call one narrow tool → inspect the result → stop, retry or escalate. Set a turn, time and cost budget.

    • Agentic AI
    • tool use
    • agent loop
    • human approval

  6. 6 · Earn production trust

    Evaluate quality and safety across real distributions; protect data and actions; make failures observable and reversible.

    Build evidence: Add traces, regression cases, permissions, guardrails, approval for consequential actions, staged rollout and rollback. Review cost and latency with quality.

    • Evals
    • guardrails
    • observability
    • rollback

Term map

Where the tools fit—and where they do not

n8n

A visual workflow-automation platform—not a substitute for understanding data, APIs, failures or permissions.

When: Use at step 4 after you can draw and test the workflow without it.

OpenClaw

A self-hosted gateway and runtime for persistent, tool-using agents. Its authority, credentials, channels and host access create a real security boundary.

When: Explore after steps 5–6, first with isolated data, minimal tools, sandboxing and explicit approvals.

AGI

An evolving capability and research horizon, not an implementation layer, framework or beginner prerequisite.

When: Track claims critically, but build today's measurable systems instead of making an AGI prediction your roadmap.

Multi-agent

Several agents coordinating through manager or handoff patterns; it adds failure modes, context boundaries and operating cost.

When: Only after one bounded agent is measured and a specific coordination problem remains.

  1. 1 · Problem, software & model foundationsStart from an explicit user need, deterministic baseline and test cases—not a framework or an autonomous agent.
  2. 2 · Prompt contracts & grounded answersMake one model call testable, then add retrieval only when the task needs owned, current or domain-specific evidence.
  3. 3 · Workflows, tools & one bounded agentKeep known steps deterministic; add an agent loop only where the model must choose among bounded next actions.
  4. 4 · Evaluation, guardrails & operationsMake AI behavior reviewable, observable, permission-aware and reversible before another person depends on it.
  5. 5 · Runtime choices & research horizonsChoose deeper infrastructure because measured work requires it—not because a new agent framework or AGI headline exists.

Roadmap stage

1 · Problem, software & model foundations

Start from an explicit user need, deterministic baseline and test cases—not a framework or an autonomous agent.

What to learn

  • Forward engineering: requirement → design → implementation → tests and evidence.
  • Python or TypeScript, HTTP APIs, JSON, Git, testing and secure secret handling.
  • Tokens, context limits, sampling, model uncertainty and a deterministic baseline.

Enough for now

You can explain the user outcome and constraints, run the baseline, protect a secret and distinguish a requirement from generated output.

Practical task

Write a one-page feature specification, eight labelled cases and a deterministic text-matching baseline over five harmless documents before calling a model.

Roadmap stage

2 · Prompt contracts & grounded answers

Make one model call testable, then add retrieval only when the task needs owned, current or domain-specific evidence.

What to learn

  • Prompt engineering as interface design: instructions, examples, context and structured output.
  • RAG: ingestion, chunking, retrieval, augmentation, generation, citations and refusal.
  • Evaluation sets for answer quality, source recall and missing-evidence behavior.

Enough for now

You can version a prompt, trace an answer to retrieved evidence and show with tests when the system must refuse.

Practical task

Add a schema-constrained answer to the baseline. Then add retrieval with visible sources and rerun every success, refusal and failure case.

Roadmap stage

3 · Workflows, tools & one bounded agent

Keep known steps deterministic; add an agent loop only where the model must choose among bounded next actions.

What to learn

  • AI workflows: trigger, validation, retrieval, model call, transform, approval, action and logging.
  • n8n or code as implementations; retries, timeouts, idempotency and partial failure as concepts.
  • Agent loop: observe → decide → use one narrow tool → inspect → stop, retry or escalate.

Enough for now

You can justify workflow versus agent, reproduce a failed run and prove that turn, time, cost and tool authority are bounded.

Practical task

Implement one read-only workflow in code or n8n. Add a bounded single-agent branch with one tool, explicit exit conditions and a human handoff; compare it with the fixed workflow.

Roadmap stage

4 · Evaluation, guardrails & operations

Make AI behavior reviewable, observable, permission-aware and reversible before another person depends on it.

What to learn

  • Versioned prompts, retrieval data, model settings, traces and representative evaluation cases.
  • Least-privilege tools, prompt-injection boundaries, privacy review, approvals, refusal and human escalation.
  • Retry and loop limits, cost, latency, quality monitoring, staged rollout and rollback.

Enough for now

You can show evidence for a release decision, reproduce model and prompt settings, and stop or roll back a harmful regression.

Practical task

Create a release gate with representative evals, permission checks, an approval boundary and explicit refusal tests. Compare two versions and document quality, cost, latency and known failure modes.

Roadmap stage

5 · Runtime choices & research horizons

Choose deeper infrastructure because measured work requires it—not because a new agent framework or AGI headline exists.

What to learn

  • OpenClaw and other runtimes: workspaces, sessions, memory, tool policy, sandboxing and trust boundaries.
  • Multi-agent manager or handoff patterns only for a measured coordination problem.
  • Fine-tuning, self-hosting and AGI research as separate decisions—not one beginner stack.

Enough for now

You can reject unnecessary autonomy, explain the selected trust boundary and show why the added runtime or agent is worth its cost.

Practical task

Write an architecture decision record comparing your current bounded system with one runtime or multi-agent option. Include the measured need, new authority, failure modes, operating cost and rollback plan.

From skills to a destination

Where could you take this?

The career roadmap explains what to learn. A goal guide helps you put those skills to work. Start with one—not every route at once.

You read the roadmap—now gather evidence

Test whether you actually like the work.

Start the career experimentEngineering foundations

Apply engineering practice to your final-year project →