DEV Community: mycel

Wiring Your AI Agent into a "Mycelium Network": A Zero-Dependency MCP Server in Production

mycel — Sun, 01 Nov 2026 23:10:23 +0000

Wiring Your AI Agent into a "Mycelium Network": A Zero-Dependency MCP Server in Production

We opened up the agents on our self-hosted AI platform to external agents via a single MCP server. External agents can now hire agents on our platform and get billed per task. This post documents the full implementation and three real pitfalls we hit.

Background: The protocol layer is crowded, the integration layer is still a construction site

The agent-collaboration protocol space moved fast in 2026: A2A (Agent2Agent) hit v1.0 in March, counted 150+ supporting organizations by its April anniversary, and got native integrations in AWS Bedrock AgentCore, Azure AI Foundry, and Google Cloud. In August it moved into the Linux Foundation's Agentic AI Foundation alongside MCP.

But protocol maturity doesn't mean you can actually use it. For indie developers the real situation is:

MCP solves "agent connects to tools" — the ecosystem is alive;
A2A solves "agent connects to agents" — the standard exists, but how an ordinary platform exposes its agents as callable nodes for external agents has very little practical documentation.

Our self-hosted platform Mycel runs a few published agents (a life-secretary, a full-stack partner) that talk to each other through an internal A2A v1.0 JSON-RPC gateway (message/send), with a per-task credit billing system already in place. What was missing was an external "hypha" — a way for any MCP client (Claude Code, Cursor, Codex CLI...) to mount our network with one config line, discover and hire our agents.

So we built mycel-mcp.

The design: 5 tools, zero new dependencies

The MCP Streamable HTTP protocol surface is narrow. We added a single FastAPI router (mounted at /api/v1/mcp) to our existing backend — no new dependencies, just the fastapi and httpx we already had.

Five tools exposed:

Tool	Purpose	Auth
`mycel_discover`	List hireable agent nodes on the platform	No key
`mycel_models`	Query platform LLMs and credit prices	No key
`mycel_hire_agent`	Hire an agent to run a task (billed)	API key
`mycel_task_status`	Check a hire task's status	API key
`mycel_balance`	Query credit balance	API key

Two design decisions worth noting:

1. Keyless read-only discovery. discover and models work without an API key. An external agent can mount us with zero credentials and still see what's in the network — mycelium logic: let spores land on your doorstep before negotiating. All write-path tools require a key.

2. Hiring goes through our internal A2A gateway — we didn't rewrite the execution layer. mycel_hire_agent forwards to the platform's own A2A v1.0 message/send call. Execution, billing, and access control all reuse the existing stack; the MCP layer is a thin protocol translator:

MCP tools/call(mycel_hire_agent)
  → POST /api/v1/a2a (JSON-RPC message/send, X-API-Key forwarded)
    → agent runtime executes → credits deducted → artifacts returned

Implementation notes: the Streamable HTTP surface

The whole protocol surface is ~200 lines. The core requirements:

initialize → return protocolVersion, capabilities, serverInfo, and set the Mcp-Session-Id response header;
Every notifications/* (no id) → 202 with empty body;
tools/list / tools/call / ping → normal JSON-RPC responses;
Response format follows the client's Accept header: include application/json and you can return plain JSON; otherwise wrap in a single SSE frame (data: {...}\n\n, text/event-stream).

Most tutorials push you to the official SDK, but for a thin translation layer like this, hand-writing the protocol surface gives you precise control over every response shape — which matters because MCP client implementations are uneven.

Three real pitfalls

Pitfall 1: A2A v0.2 → v1.0 renamed the task-creation method.

Our gateway reports protocolVersion 1.0, but our MCP layer first called it with the v0.2-era method name tasks/send and got rejected: Method not found: tasks/send. In v1.0 the unified method is message/send (tasks/get and tasks/cancel survive). Don't trust version numbers alone — verify the actual method surface.

Pitfall 2: Private-node isolation must happen at the discovery layer, not just the invocation layer.

We have one internal expert agent with a sensitive memory toolset, hard-blocked at the execution layer (any API-side invocation is refused). But our first discover listed it anyway — name and description exposed. Invocation-layer refusal prevents execution, not reconnaissance. The fix: filter private nodes out at discovery, as if they don't exist. This applies to anyone building multi-tenant agent platforms: visibility control must take effect at listing time; never rely on invocation-time backstops.

Pitfall 3: nginx's SPA fallback silently swallows /.well-known/ discovery endpoints.

The sneakiest one. Our frontend is an SPA with location / { try_files $uri $uri/ /index.html; }. A2A's Agent Card discovery endpoint /.well-known/agent.json had no explicit location block, so try_files served index.html — HTTP 200, but the body was HTML. External agents got a 200 and thought discovery succeeded. The check is trivial but you have to remember to do it:

curl -s https://your-site/.well-known/agent.json | head -c 200
# If you see <!DOCTYPE html>, your discovery endpoint got swallowed

The fix is one exact-match location:

location = /.well-known/agent.json { proxy_pass http://127.0.0.1:8006; }

Live test transcript

Run end-to-end from an external network:

# 1. Discover nodes
→ mycel_discover
{"platform": "Mycel", "agents": [
  {"agentId": 7, "name": "生活秘书", "description": "expense tracking / schedule reminders / daily-life queries..."}]}

# 2. Hire it
→ mycel_hire_agent(agent_id=7, prompt="Introduce yourself in one sentence")
{"task_id": "aa7e5677-...", "output": "我是小禾，你的生活秘书，今天想帮你把这周的花销整理一下，省得月底乱糟糟。"}

# 3. Confirm billing
→ mycel_balance
{"balance": 812.0}   # was 813.0 — one hire, one credit

Balance 813 → 812, billing loop closed. From "external agent first hears of Mycel" to "actual hire and settlement" — zero human intervention.

How to connect

Any MCP-capable client, two lines:

{
  "mcpServers": {
    "mycel": {
      "url": "https://site.pianam.cn/api/v1/mcp",
      "headers": { "X-API-Key": "qk_your_key" }
    }
  }
}

For Claude Code:

claude mcp add --transport http mycel https://site.pianam.cn/api/v1/mcp \
  -H "X-API-Key: qk_your_key"

After that, just tell your agent: "check what agents are hireable on Mycel."

What's next

This is the first external hypha of our mycelium network (one-way: outside → platform). The road ahead:

Agent Card authentication: users package their own capabilities as hireable nodes, with signed cards recognized across boundaries;
User ↔ user hiring: user A hires user B's published agent through the platform, credits settle directly to B (a developer revenue-share system already exists, default 80%);
Persistent personal agents: everyone has their own resident agent negotiating on their behalf — that's the Instinct/Pickle layer, waiting for identity and settlement infrastructure to mature.

The protocol war's first half is over (A2A in a foundation, native cloud support). The second half is productization. Our take: multi-agent systems running in production at individual scale are still rare — and the barrier isn't technology, it's actually going and running one.

Mycel is an indie-operated AI platform (site.pianam.cn). All test data in this post is from real production runs.

The 2026 Guide to AI Coding: Best Practices for Developers

mycel — Sat, 31 Oct 2026 15:23:46 +0000

The 2026 Guide to AI Coding: Best Practices for Developers

In 2026, AI programming tools have evolved from "nice-to-have" novelties to absolute essentials. Whether you're a complete beginner or an experienced developer, mastering the right approach to AI coding will help you achieve more with less effort.

Five Practical Principles

Define your requirements clearly before asking AI to write code — Vague inputs only yield vague outputs.
Get it working first, optimize later — Don't expect AI to write perfect code in one go; have it generate a working version first.
Learn to review AI-generated code — AI makes mistakes, and you must be able to understand what it's doing.
Use AI for repetitive tasks — Boilerplate code, test cases, and documentation comments are where AI truly shines.
Keep learning — AI is a tool, not a replacement. You still need to build your own core logic and system design skills.

Common Pitfalls

Blindly copying AI code without reviewing it → Leads to hidden bugs.
Using AI to write algorithms you don't understand → Leaves you blind when debugging.
Relying entirely on AI without learning the basics → Leaves you helpless when facing complex problems.

The ultimate goal of AI coding isn't to let AI write code for you, but to free up your mental bandwidth for tasks that truly require human creativity.

Recommended Tools

Tool	Use Case	Cost
Cursor	Daily coding, refactoring	Free + Paid
Copilot	Autocomplete, small code snippets	$10/month
Mycel	Full-stack AI workspace	Pay-per-use

Pick the one that suits you best, stick with it for two weeks, and you'll see a massive leap in your productivity.

The Beginner's Guide to AI Coding: The Right Way to Write Code in 2026

mycel — Sat, 31 Oct 2026 15:17:01 +0000

The Beginner's Guide to AI Coding: The Right Way to Write Code in 2026

In 2026, AI programming tools have shifted from "nice-to-have" to "must-have". Whether you're a complete beginner or an experienced developer, mastering the right workflow for AI coding will help you work smarter, not harder.

Five Practical Principles

Describe your requirements clearly before asking AI to write code — Vague inputs only yield vague outputs.
Make it work, then optimize — Don't expect AI to write perfect code in one shot. Get it to give you a working version first.
Learn to review AI-generated code — AI makes mistakes, and you must be able to understand what it's doing.
Use AI for repetitive tasks — Boilerplate code, test cases, and documentation comments are what AI does best.
Maintain your learning ability — AI is a tool, not a replacement. You still need to build your own core logic and design skills.

Common Pitfalls

Copying AI code directly without reviewing it → Leads to hidden bugs.
Using AI to write algorithms you don't understand → You'll be flying blind when debugging.
Relying entirely on AI without learning the basics → You'll be stuck when facing complex problems.

The ultimate goal of AI coding isn't to let AI write code for you, but to free up your energy for the parts that truly require creativity.

Recommended Tools

Tool	Best For	Cost
Cursor	Daily coding, refactoring	Free + Paid
Copilot	Autocomplete, small code snippets	$10/month
Mycel	Full-stack AI workspace	Pay-per-use

Choose one that suits you, stick with it for two weeks, and you'll see a massive leap in your productivity.

3 Real Scenarios: Automating Weekly Reports and Excel Cleanup with an AI Workspace

mycel — Sat, 31 Oct 2026 14:51:30 +0000

Every Friday afternoon, someone in your team copies numbers from three apps into a spreadsheet, rewrites the same status update, and calls it "the weekly report." It's pure drudgery — and it's exactly the kind of work AI workspaces are good at.

Here are three scenarios I use weekly, each with a prompt template you can copy. They work in any AI chat tool (ChatGPT, Claude, or a multi-model workspace like Mycel); nothing here needs special infrastructure.

Scenario 1: Messy Transactions → Categorized Summary

The raw material: half-organized expense notes, chat logs, meeting scribbles. The goal: categories, dates, and a three-sentence weekly summary.

Steps:

Copy your raw text (chat logs, email threads, plain text from Excel)
Use a mid-tier model — you want reliability but not overkill
Paste this prompt:

Organize the following transaction records by category and produce a concise weekly summary:
- Categories: income, expense, meeting, to-do, other
- List specific items under each category, with dates if present
- End with a 3-sentence summary of the week's key points

[PASTE YOUR RAW TEXT HERE]

Tip: if the input format is really messy, run a cheap fast-model pass first just to normalize the text, then the mid-tier pass for the actual analysis.

Scenario 2: Weekly Report First Draft

Give the AI your raw activity list and a fixed report structure, and let it write the draft you edit instead of a blank page you fear:

You are writing my weekly report. Use this structure:
1. This week's completed work (bullet points, outcomes first)
2. In progress (with status)
3. Risks and blockers
4. Next week's plan

Tone: concise, professional, no fluff. Data comes below; don't invent facts.

[PASTE YOUR WEEK'S ACTIVITY NOTES]

The trick is the last line: don't invent facts. AI drafts are great at phrasing and structure, but the facts must come from you.

Scenario 3: Excel Data → Insights Without Formulas

Paste a table (or CSV text) and ask for analysis instead of writing VLOOKUP formulas you'll forget next month:

Here is my data table in CSV format. Please:
1. Point out anomalies (duplicates, outliers, missing values)
2. Summarize totals by category
3. Suggest 3 follow-up questions a manager might ask about this data
4. Output a cleaned version of the table

[PASTE CSV]

Scenario 3 is where structured + unstructured thinking really pays off: the model catches the duplicate row you'd miss and flags the outlier your boss would ask about.

Why This Beats Manual Work

Consistency: same structure every week, no "wait, which template did I use?"
Speed: 15 minutes of formatting becomes 2 minutes of review
Better questions: when the AI proposes "3 follow-up questions," you look more prepared in the meeting, not less

Cost Note

These are all short-context tasks. On tiered platforms, they belong on the low/mid tier — my weekly-report batch on Mycel costs about 10-20 credits a week (roughly $0.015-0.03). The expensive reasoning tier is unnecessary for this work; save it for actual analysis problems.

The templates above are format-agnostic. If your workspace supports file upload or desktop assistants (Mycel's does), you can skip the copy-paste and feed documents directly — but the prompts stay the same.

Calling the Qwen API for the First Time: From Key to Working Code

mycel — Sat, 31 Oct 2026 14:46:22 +0000

Getting a large model API to actually respond can feel like a rite of passage. This is the zero-to-first-request walkthrough I wish I'd had: no framework, no SDK — just curl and an OpenAI-style endpoint.

We'll use Qwen (Tongyi Qianwen) as the model, accessed through a compatible API gateway. The same pattern works for almost any OpenAI-compatible provider.

Step 1: Get an API Key

If you're going direct to Alibaba Cloud, you'd create a DashScope key. But many gateway platforms let you skip that: for example, on Mycel's developer platform you register an app and get a key immediately:

Sign up at the platform's developer console
Create an application
Grab the API Key from the app detail page

⚠️ Treat your key like a password. Don't commit it, don't paste it in screenshots.

Step 2: Understand the Shape of the Request

OpenAI-compatible APIs all look the same:

POST to a /chat/completions endpoint
Your key in a header (X-API-Key or Authorization: Bearer, most gateways accept both)
JSON body with a model name and a messages array

Step 3: The First Request

curl -X POST \
  'https://api.example-gateway.com/api/v1/open/chat/completions' \
  -H 'X-API-Key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "qwen-plus",
    "messages": [
      {"role": "user", "content": "Say hello in one sentence."}
    ]
  }'

If everything is right, you'll get back JSON with a choices[0].message.content field containing the model's reply.

Step 4: Read the Response Properly

The three fields worth knowing:

{
  "choices": [
    {
      "message": { "role": "assistant", "content": "Hello! 👋 ..." }
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 12
  }
}

choices[0].message.content — your answer
usage — token counts; on per-call-priced platforms you may not need this, but on token-billed ones it's your cost driver
error — when things fail, read this first

Step 5: Python, Minimal

No SDK needed:

import requests

resp = requests.post(
    "https://api.example-gateway.com/api/v1/open/chat/completions",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "model": "qwen-plus",
        "messages": [{"role": "user", "content": "Write a haiku about APIs."}],
    },
    timeout=60,
)
print(resp.json()["choices"][0]["message"]["content"])

Common First-Timer Errors

Symptom	Likely cause
401	Key wrong, or wrong header name
404	Wrong endpoint path — check `/v1/` placement
400 `model not found`	Model name typo (`qwen-plus` vs `qwen_max`)
Empty `content`	You hit a safety filter or the model needs a longer prompt

Wrapping Up

That's the whole journey: key → header → POST → parse. From here you can add streaming (SSE), function calling, and system prompts — but the core request never changes shape.

The examples here follow the pattern Mycel's developer API uses (OpenAI-compatible, key-per-app). If your platform is OpenAI-compatible too, the code above works with a URL and key swap.

How to Choose the Right AI Model Tier Without Wasting Money: flash vs turbo vs plus

mycel — Sat, 31 Oct 2026 14:46:17 +0000

If you're using an AI API platform, you've probably stared at a pricing page wondering: do I really need the expensive model for this?

Picking the wrong tier either wastes money (using a reasoning model for a quick lookup) or wastes time (using a lightweight model for a complex task and getting garbage output).

Most multi-tier platforms — including our own workspace Mycel — follow the same three-tier pattern, so this guide applies broadly. Here's how I think about it.

The Three Tiers

flash — lightweight and fast. Built for quick Q&A, simple instructions, and basic lookups. Cheapest per call.
turbo — the balanced tier. Good quality with reasonable latency. Handles mid-complexity tasks: longer text polishing, code snippet generation, multi-turn conversations.
plus — deep reasoning tier. Uses significantly more compute. For complex logic, domain analysis, and long-document processing.

A Simple Decision Table

Your task	Pick	Why
Daily Q&A, simple commands, fact lookups	flash	Fastest, lowest cost
Text polishing, code generation, multi-turn chat	turbo	Quality/cost balance
Complex reasoning, professional analysis, long docs	plus	Much stronger comprehension and generation

Do the Math

Take a typical token-credit platform (1 unit ≈ 100 credits, like Mycel's system):

flash: 1 credit/call → about $0.0014/call
turbo: 2 credits/call → about $0.0028/call
plus: 5 credits/call → about $0.007/call

Now imagine 200 calls a day:

All on plus: 1,000 credits/day
Right-tier routing (say 70% flash, 25% turbo, 5% plus): ~185 credits/day

That's an 80% cost reduction just by not lazily defaulting to the biggest model. No code changes. No infra work. Just routing discipline.

Practical Rules of Thumb

Default to flash. Only escalate when the output isn't good enough.
Escalate on failure, not on fear. If flash returns fine for your summarization task, you didn't need turbo.
Reserve plus for actual reasoning: multi-step analysis, nuanced tradeoffs, or documents over ~50 pages.
If you bring your own API key (BYOK), many platforms only charge a small channel fee — worth checking before you commit to their bundled models.

One Caveat

Tiers change as models get updated. Whatever platform you use, check the live docs before building a cost model on top of my numbers — treat the pattern (light/balanced/deep) as stable, not the exact prices.

If you're curious what this looks like in practice, Mycel (where I work) runs exactly this three-tier model with per-call pricing. But the tier-routing logic above works on any platform with a similar setup.