Shrimp Task Manager Research Mode Is Live: Equipping AI with Real Technical Research Capabilities

Siage — Mon, 26 May 2025 16:49:04 +0000

From day one, the goal of Shrimp has never been just to delegate or break down tasks to an AI assistant, but to develop an assistant that possesses true upstream and downstream thinking—just like an engineer.

However, during development, I quickly realized something: before most engineering tasks even begin, what’s truly needed isn’t “execution” — it’s “research.”

That’s why in this update, I introduced the brand-new Research Mode. This article will walk you through its design rationale, practical workflow, and a full experiment I conducted using it.

Background: Why Do We Need “Research Mode”?

In software development, the most common issue isn’t “not knowing what to do,” but rather not knowing which solution is more appropriate.

Here’s a real example: say I want to optimize Laravel’s search capabilities. The potential options include Scout with Meilisearch, Elasticsearch, Algolia, or even rolling a custom solution with SQL and Redis.

But each option comes with trade-offs, such as:

Cost, performance, and maintenance complexity
Integration difficulty within the Laravel ecosystem
Whether the user experience actually improves

You can’t solve this kind of problem with a single prompt. You also can’t just tell AI to “pick the best one,” because without enough context and exploration, it simply doesn’t know what “best” means.

That’s why I designed a new prompt interface and task flow — Research Mode.

How Research Mode Works

Unlike typical prompt-response interactions, Research Mode works through a multi-stage command-driven process, enabling complete technical research.

The general process looks like this:

Initiate Research Mode

Use the research_mode tool to start a research session, clearly defining a goal (e.g., “Improve Laravel search performance”).
Initial Exploration

Shrimp searches the web to learn about commonly used community practices (e.g., Laravel Scout, Redis caching, aggregated search strategies).
Focused Investigation

It then dives deeper into specific technologies, gathering details on implementation methods, deployment tips, and potential pitfalls.
Compare with Existing Codebase

It reads the current project code to assess relevance, diagnose weaknesses, and identify applicable improvements.
Generate Conclusions

Finally, Shrimp produces a structured “Research Report” with actionable insights.

Real-World Test: Researching Best Practices for Laravel Search

To test Research Mode, I used a real task: Improving the structure and performance of an existing Laravel search system.

The process began with broad exploration, gathering popular techniques, then diving deeper into specific technologies like Scout + Meilisearch and Redis caching. It referenced Laravel docs, community articles, and performance benchmarks.

The final research report included:

Diagnostic analysis of the current code (e.g., multiple model LIKE queries, no caching, no tracking)
Pros and cons of different technical solutions
Concrete enhancement recommendations

Integrating with Task Systems: From Research to Execution

Once the research report is complete, it can be immediately converted into executable tasks using plan_task, followed by structure and dependency checks using analyze_task and reflect_task.

The full flow becomes:

research_mode → Build knowledge base and research flow
plan_task → Convert conclusions into actionable tasks
analyze_task → Analyze current project structure and constraints
reflect_task → Refine task granularity and correct any flaws
split_tasks → Output a final structured task board

Tasks are no longer arbitrary checklists — they are evidence-based decisions.

Tool Positioning and Future Direction

With Research Mode added, Shrimp now complements its task-oriented foundation with exploratory thinking.

This is especially helpful for situations where there’s no clear answer, like:

Should we adopt this library?
Is this architecture suitable for our project?
Are there more lightweight alternatives?

Conventional AI tends to guess based on prior knowledge. Shrimp’s Research Mode mimics how an engineer would “dig into the facts before making a decision.”

Usage Tips and Open Source Project

This research workflow is already integrated into the MCP Shrimp Task Manager and works seamlessly within the automated development environment for Cursor IDE.

You can combine it with the task management module — use research_mode to identify problem context and justification before jumping into task decomposition.

📌 Open source project: mcp-shrimp-task-manager

✅ For best results, we recommend using claude-4-sonnet for this research mode experience.

Why Your Coding Agent Keeps Failing — And How to Make It Project-Aware with MCP

Siage — Mon, 21 Apr 2025 11:09:29 +0000

Coding Agents: Why “Smart” Isn't Always “Accurate”

We often imagine a Coding Agent as a reliable assistant who can generate clean, consistent, and well-integrated code.

But in reality, the experience can be… frustrating:

Knowledge Gaps: The agent doesn’t understand your codebase, so it guesses—often wrongly.
Wrong Task Decomposition: It breaks down the task, but into steps that don’t fit your project’s actual structure.
Repeating Mistakes: Even if you correct it once, it forgets, and the same mistakes come back next prompt.

MCP‑Shrimp Task Manager: Not a Task Manager, but a Context Bridge

That’s why I built MCP‑Shrimp Task Manager —

It’s not just about managing tasks. It’s about helping your Coding Agent understand your project.

🧠 Init rules optimized for agents, not humans: The rules.md file isn’t a wall of text. It’s concise, context-rich, and focused on what the Agent needs to know.
🪄 Guide the agent, don’t spoon-feed it: MCP doesn’t inject your whole schema or codebase into the prompt. Instead, it teaches the agent how to find and use the right references.
🔁 Think → Act → Reflect: Each task uses Chain-of-Thought reasoning. The agent breaks it down, explores context, builds a solution, and reflects on alignment.

How is this different from traditional task managers?

Feature	Typical LLM Task Management	MCP‑Shrimp Task Manager
Task Planning	Sends prompt to LLM directly	Guides agent to plan based on real project context
Project Knowledge	Needs RAG/embedding setup	Context given via optimized init rules
Code Fit	Often mismatches styles or patterns	Generates code aligned to current project
Quality Check	Relies on human review	Encourages agent self-reflection and correction

Example: Adding a Comment Module

💬 “I need a comment module in my app”

Traditional flow

→ Agent returns generic blog-style code

→ Doesn’t match existing project structure

→ Manual fixes everywhere

MCP flow

✅ Agent loads project-aware rules.md

✅ Searches for existing Comment model

✅ Detects validation uses Joi

✅ Generates matching model/controller/test

✅ Reflects: Are names and structure consistent? Yes → Done

Make Your Agent Project-Aware — No Plugins, No APIs

🚀 GitHub: https://github.com/cjo4m06/mcp-shrimp-task-manager
🌐 Docs & Quick Start: https://cjo4m06.github.io/mcp-shrimp-task-manager/

With no API costs, no complex integrations, just well-designed prompts and structure —

you can make your Agent not just smart, but project-aligned.

DEV Community: Siage