Agent Engineering

Prove you can architect, build, and operationalize a production-grade agent from scratch. This certification requires you to design a multi-node agent with knowledge bases, structured outputs, conditional logic, and Profound Data.

Target Audience

Marketing Engineers

Skills

Agent Architecture, Automation Design

Submission Type

Project Based Assignment

About

You will build a working agent from scratch, export it, and walk us through every node, every variable name, and every prompt decision in a recorded Loom video.

Lessons 21 through 23 taught the five node categories (Data, Research, LLM, Integration, Logic), the template modification loop, knowledge base architecture, structured outputs, conditional branching, and Profound Data integration. This certification tests whether you can synthesize all of that into a single agent that solves a real problem.

Your agent must demonstrate mastery across the full stack of concepts from the Agents unit.

Requirements

1. Multi-category node architecture. A minimum of 12 nodes spanning all five node categories: Data, Research, LLM, Integration, Logic. We are not counting nodes for the sake of counting. Each one must serve a clear purpose in the chain.

2. Knowledge base with longitudinal tracking. At least one knowledge base configured as persistent memory using the baseline advancement pattern: read previous baseline, compare against current data, overwrite for next run. Your agent should get smarter over time, not just run the same check with no memory.

3. Structured outputs driving conditional logic. At least one LLM node must use structured output fields, Boolean for conditionals, String for downstream nodes, to make your agent programmable, not conversational. A conditional node must branch on that output.

4. Profound Data integration. At least one Profound Data node (Visibility Score, Citation Share, or Citation Pages) with intentional platform filtering and date range configuration. We will check that you selected the right data type for your use case, not just the first option in the dropdown.

5. Respectful automation. Your agent must not fire notifications regardless of results. Conditional logic should gate delivery so stakeholders only receive output when something has genuinely changed or is worth reading.

6. Variable naming that tells a story. We will read your output labels. Naming a variable "output1" tells us nothing. Naming it "SF Baseline" or "Current Competitor Pricing" tells us you understand that variables are the glue between nodes and that naming conventions are an architectural decision.

7. Detection, Analysis, Delivery, Update architecture. Your agent should follow the pattern taught in Lessons 22 and 23, or present a justified deviation. Detection gathers current state. Analysis compares against baselines. Delivery communicates findings. Update advances the baseline for the next run.

How We Evaluate

This is not a checkbox exercise. We are evaluating architectural thinking, not node count.

A 15-node agent with sloppy variable names and generic prompts will not pass. A 12-node agent with tight wiring, intentional structured outputs, and a clear operational loop will.

What You Submit

Two deliverables.

1. Your exported agent file (JSON). Open the agent in Profound, click the three dots in the upper left corner of the agent view, select "Export as JSON." This produces a .json file containing your full agent configuration: every node, every connection, every prompt, every variable name. Upload this file directly.

2. A Loom video walkthrough, 10 to 15 minutes. Walk through your agent node by node. Explain your variable wiring, defend your prompt engineering choices, show how your conditional logic gates delivery, and demonstrate at least one full run with real output.

We want to hear the reasoning, not just a tour of the interface.

What Passing Sounds Like

A failing walkthrough: "This node scrapes the page and sends it to the next node."

A passing walkthrough: "This Web Page Scrape node pulls the competitor's pricing page. I labeled its output 'Current SF Pricing' so the downstream Detection LLM can compare it against the 'SF Baseline' variable read from the knowledge base at the start of each run. If the Detection LLM returns Boolean true for 'pricing_changed,' the conditional routes to the Diagnosis branch. If false, the agent skips delivery entirely — we don't send a Slack message that says nothing changed."

That level of specificity is what separates someone who built an agent from someone who understands agent architecture.

Submit for certification

Rubric

Submissions are evaluated across five dimensions, each scored on a 1–5 scale

Category	Weight	What we're evaluating	3 - Excellent	2 - Meets expectations	1 - Needs improvement
Agent Architecture & Node Design	25%	Can you design a multi-node agent that uses all five node categories with intentional sequencing and clear data flow?	All five node categories used with purpose. Variable names tell the full story ("SF Baseline" → "Pricing Change Detected" → "Diagnosis Report"). Tight Detection → Analysis → Delivery → Update loop, no orphaned nodes. Walkthrough shows individual node testing and explains what changed after the first run.	Four or five node categories with logical sequencing. Descriptive variable names. Detection → Analysis → Delivery → Update pattern present with minor gaps. Walkthrough references how variables connect nodes.	Fewer than three node categories. Generic variable names ("output1"). No discernible operational loop. No individual node testing evident.
Knowledge Base & Longitudinal Tracking	25%	Can you configure knowledge bases as persistent memory and implement baseline advancement for longitudinal monitoring?	Full loop: reads previous baseline, compares against current, delivers findings, overwrites baseline for next run. Intentional file naming (e.g., separating competitor baselines from internal). Walkthrough articulates why the overwrite pattern prevents stale comparisons.	Knowledge base has both read and write operations. Baseline concept exists but overwrite pattern may be inconsistent. Walkthrough explains the KB's role in the operational loop.	No knowledge base, or KB is read-only with no baseline concept. Each run is independent. No memory architecture.
Structured Outputs, Conditionals & Respectful Automation	25%	Can you make an agent programmable (not conversational) using Boolean fields, conditional branching, and notification gating?	Booleans drive conditionals, Strings carry structured data downstream. Every delivery path is gated: stakeholders only hear from the agent when something changed. Walkthrough explains why structured outputs make agents programmable.	At least one structured output field driving a conditional branch. Notification gating present but may not cover all delivery paths. Walkthrough addresses conversational vs. programmable design.	Free-text output only. No conditionals connected to structured Booleans. Agent fires notifications on every run regardless of results.
Prompt Engineering & Loom Walkthrough	25%	Can you write multi-node prompts that build on each other across the chain, and can you articulate your design decisions under scrutiny?	Each prompt references upstream outputs with context for why they matter. Includes "connect the dots" synthesis instructions. Loom walks through every node, defends prompt choices, shows a live run, and explains baseline advancement. Speaks as a marketing engineer.	Prompts reference upstream variables by name and build context across the chain. Walkthrough covers architecture and key decisions but may skip prompt-level details or a complete live run.	Generic or copy-pasted prompts. Variables referenced inconsistently. Walkthrough describes what nodes do without explaining why. No live run.