Autonomous Workflow Agent
An AI teammate for one job done well — built fully in n8n or in code.
Build the AI agent that solves one real workflow end-to-end. Flagship pitch: an autonomous code review agent for OSS maintainers — they drown in low-quality PRs from random contributors. Your agent does first-pass review (style violations, missing tests, security smells, convention drift) so the maintainer only opens PRs that are worth their time. You can build this entirely in n8n (triggers, tool calls, branching, retries, human approval), or code-first with LangGraph + MCP. Real audience: tens of thousands of solo OSS maintainers. Variations let you build for inbox triage, scheduling, research, or DevOps incident response instead — same skill graph, different user. The portfolio outcome: 5+ real PRs reviewed on a real OSS repo, with the maintainer's reaction recorded.
The product in detail
The product is an AI teammate that owns one specific job and does it reliably enough to trust unsupervised. The flagship pitch: a code review agent. You connect it to a GitHub repository and it reviews incoming PRs — flagging style violations, missing tests, security smells, and convention drift. The maintainer's inbox goes from 30 low-effort PRs a day to 5 that are actually worth opening. The agent's reasoning is visible in every comment so the contributor learns from the feedback, not just gets blocked by it.
The target user is a solo OSS maintainer — someone who owns a popular GitHub repo and gets buried under low-quality PRs from drive-by contributors. They love that people contribute, but every PR costs them 20 minutes of triage. They'd run an AI co-maintainer if it didn't make things worse. Adjacent personas include indie founders shipping fast who want a second pair of eyes, and engineering managers triaging a team's PR backlog at scale.
Real market: Cursor ($60M raised), Devin ($21M valuation), Aider (OSS, 20k+ GitHub stars), Cline (OSS), Continue (Series A). The autonomous-coding category exploded in 2025-26. The opportunity below them is narrow-scope specialists — agents that do ONE thing (code review, async standups, inbox triage) instead of trying to be a full software engineer. Lower-stakes, higher-trust, and much easier to ship as a real product.
Technically you can take two equivalent implementation paths. Path A (no-code/low-code): build the full workflow in n8n with event triggers, LLM/tool nodes, branching logic, retries, error routes, and human-in-the-loop approvals. Path B (code-first): build a manual ReAct loop first (observe → think → act → loop, hand-coded, no framework), then upgrade to LangGraph for stateful orchestration with conditional edges and persistent memory. In both paths, add a third tool that calls into Project 1's vector store for context retrieval, and stream reasoning/status to the UI so users can trust and intervene when needed.
What you ship: a deployed agent solving a real workflow on real-world inputs. For the code-review variant, that means a GitHub App reviewing real OSS PRs with the maintainer's recorded reaction. Public repo with 4 checkpoint PRs documenting the build journey. A 3-minute Loom demonstrating 5 different prompts. The custom MCP server runnable as a standalone process anyone can plug into — the artifact that signals you're current with frontier AI tooling.
Pick what you'll build
This is one project with one skill graph — but you pick the product framing that fits your interests or career goals. Each option below is a viable portfolio piece. We'll narrow it together in the kickoff call.
- Code review agent — reviews real PRs on a real OSS repo. Audience: solo OSS maintainers drowning in low-effort PRs.
- Async standup bot — reads your week's PRs, commits, Slack chatter; writes the standup. Audience: distributed eng teams.
- Inbox triage agent — categorizes email, drafts replies in your voice, schedules follow-ups. Audience: founders / sales reps.
- Calendar / meeting prep agent — reads your week, drafts agendas, surfaces relevant docs. Audience: PMs and execs.
- n8n-first workflow agent — built entirely in n8n with retries, approvals, and Slack/Notion/GitHub integrations.
- DevOps incident responder — paged → queries logs + Datadog → proposes a fix. Audience: on-call engineers.
- Travel planner — constraints in, full itinerary out, bookings included. Audience: indie travel-blog readers.
- Agents are the 2nd-most-cited concept (52% posts, 25% interviews).
- The cross-reference reveals a stack of tacit must-knows here — Tool Use (Δ+6), ReAct (Δ+5), Agentic Patterns (Δ+8).
- MCP is the frontier signal (every Anthropic JD requires it).
- Building this after Project 1 means you already understand prompt and LLM dynamics; agents add the decision loop on top.
Research backing this project
Every project on projeckt.ai is calibrated against real job posts and real interview questions, not opinion. Here's the data behind this one.
- •Tool Use / Function Calling (Δ+6)
- •ReAct Prompting (Δ+5)
- •Agentic Patterns (Δ+8)
Themes covered
Each chip shows how many of the 46 analysed job posts cite this theme.
Justified by real job posts
Verbatim quotes from the postings that drove the design of this project.
“Production experience with LLMs: prompt engineering, agent development, evaluation frameworks, MCP, deployment at scale”
“Deliver technical artifacts (MCP servers, sub-agents, agent skills) for production workflows”
“Designing and implementing stateful agentic workflows using frameworks like LangGraph or custom Python/TypeScript solutions”
“Custom Agents that automate recurring workflows (task filing, report writing, KB queries)”
What you'll be able to do
- 1Implement function calling / tool use against OpenAI's or Anthropic's API directly — no framework abstraction
- 2Implement ReAct from first principles: observe → think → act → loop
- 3Distinguish ReAct vs Plan-Execute vs Reflection and pick the right pattern for a problem
- 4Build a stateful agent with LangGraph — explicit state machine, conditional edges, persistent memory
- 5Build and consume an MCP server — implement at least one custom MCP tool
- 6Detect and break agent infinite loops (timeout, max-steps, repeated-action detection)
- 7Define structured output contracts for tools (input/output JSON Schema)
- 8Stream agent reasoning to the UI (visible 'thinking' steps)
- 9Reason about cost / latency tradeoffs in agent design (single strong LLM vs router with cheaper model for tool selection)
Tools you'll learn
Hands-on with these tools across the paid and open-source stacks. The Paid / OSS / Both label shows which stack each tool belongs to.
Week-by-week checkpoints
Each checkpoint is a Pull Request to your public GitHub repo. Rohan reviews on the PR; merge = checkpoint complete.
Pick your path. n8n path: event trigger + LLM/tool nodes + branching + retries + error route, with 2 tools (for example GitHub + Slack). Code path: single-file Python agent with observe → think → act → loop and 2 tools.
Agent solves a problem requiring tool use; flow includes retry/failure handling; runaway loops prevented with step/time limits.
- •Function calling API (OpenAI / Anthropic)
- •n8n flow orchestration basics
- •Structured tool schemas (JSON Schema)
- •ReAct reasoning pattern
- •Max-step / repeated-action detection
n8n path: introduce sub-workflows, conditional branches, persistent execution data, and add a 3rd tool that calls Project 1's vector store. Code path: rewrite in LangGraph with conditional edges + persistent state in SQLite + same 3rd tool.
Same problem solved; state machine visualizable; conversation resumable across restarts.
- •Stateful agent orchestration
- •State graph design + conditional routing
- •Persistent agent memory
n8n path: production integrations hardened (auth, retries, idempotency, approval gates) with run-level tracing and alerts. Code path: custom MCP server exposing 2+ tools, consumed via MCP client. Both paths include LangSmith / LangFuse-style tracing for LLM and tool calls.
Trace dashboard shows full request flow with timing and failures; integrations are stable under retry/error scenarios.
- •Workflow reliability (retries, idempotency, approval gates)
- •MCP server / client architecture
- •OpenTelemetry-style agent tracing
- •Cost / latency attribution per step
Web UI streams agent reasoning steps. 'Thinking…' + 'Calling tool X with args Y' + final answer. README explains architecture choices (ReAct → LangGraph → MCP). 3-min Loom.
5 prompts demo'd in Loom; reasoning steps visible; tool calls labeled.
- •Streaming agent traces to UI
- •Explaining architecture choices in writing
- •Portfolio framing for agent projects
Pick your stack
Same skills, different credentials. Start free with the OSS stack or use the paid stack to learn directly on production tools.
| Tool | Purpose | License | Hardware | Market equivalent |
|---|---|---|---|---|
| Ollama + Qwen 2.5 14B or DeepSeek R1 7B | Local LLM with tool calling | MIT / various | Mac M-series with 16GB+ RAM | Claude Sonnet / GPT-4o |
| LangGraph | Stateful orchestration | MIT | Free | Same |
| LangFuse (self-hosted) | Tracing + observability | MIT | Docker | LangSmith |
| MCP Python SDK + custom MCP server | Tool integration | MIT | Free | Same |
| FastAPI for tool endpoints | Backend for tools | MIT | Free | — |
Estimated cost: $0/month — self-hosted on the same VPS as Project 1.
Interview questions you'll be ready for
Real questions from 13 sources, mapped to the skills this project builds.
Ready to start building?
Book a free 30-minute project planning session. We'll tailor this project to your stack, team, and goals.