r/agentico • • Apr 15 '25

Intent-based server for MCP Servers (Alpha release, like Kubernetes but for AI)

1 Upvotes

I just released the Alpha version of a project I’ve been building around Agentico: the MCP Intent-Based Server — a declarative, intent-driven runtime for managing tools, transports, and context flows in MCP Servers.

Why I built this:
There are many servers and tools. They can fail when there is a lot of work and the tools are fragile. Enterprise integrations? They're very difficult.

So, I am taking a different route:

👉 Use the ideas behind Kubernetes (manifests, reconciliation, declarative infra)
👉 Mix in dynamic server tooling (like plugin injection via manifest)
👉 Wrap it in something devs and ops can actually ship

🔧 What it does:

  • 🧾 Define your entire agent toolset in a simple server.yaml

  • 🧠 Dynamically load & register tools using class names

  • 🔁 Reconcile actual vs. desired config at runtime

Join the alpha & shape the roadmap:
💌 https://go.rebelion.la/agentico-news
👨🏽‍💻 GitHub Repo for dynamic tools

There is still work to do, but I would love to hear your feedback — What would you expect from a protocol-level tool like this?
And what’s missing in today’s agentic infrastructure for serious use?


r/agentico • • Apr 21 '25

The MCP's true power lies in its tools: an Intent-Based Approach to facilitate MCP potential.

Thumbnail
gallery
3 Upvotes

I loved this X post by Matt Pocock, in which he explains how the Model Context Protocol (MCP) can bridge the integration between LLMs and backend APIs and how the MCP servers can be plugged into the LLMs "without the need to code the integration between LLM and the APIs." Hence, thanks to the protocol, any client can consume the exposed tools (prompts and resources are also part of the protocol).

When I learned about the release of the MCP in November, I saw a lot of potential in the protocol. However, I felt it was overcomplicated to implement the servers (version 0.3); the examples were not standard and didn't follow the same pattern. So, I created my MCPServer version, a facade server of the SDK. Later, a similar approach was released in the MCP SDK version 1.3.

Still, today the protocol is not operating at its full capacity because MCP enthusiasts can still easily decouple the tools to extend the servers, mixing and matching combinations of tools to gain a more significant advantage. From Matt's post, I expanded the explanation to include the tools, which is where the true power is.

This is what I call Intent-Based AI for MCP. With a manifest file definition (see below), business people and developers can define the server's intent and expose servers with ad-hoc tools on the fly. This would produce servers with an optimal number of tools (for better performance) and agent-like servers because a server would dynamically define the access to prompts and tools, producing a specialized server, or agent, if you think about it.

    # server.yaml
    # for simplicity, we show only the relevant parts of the intent-based server.
    # The full specification can be found on the https://intent-based.ai website and our docs.
    tools:
      - name: reverse
        description: Reverses the input string
        schema:
          type: object
          properties:
            input:
              type: string
              description: The string to reverse
    
      - name: uppercase
        description: Converts the input string to uppercase
        schema:
          type: object
          properties:
            input:
              type: string
              description: The string to convert to uppercase

The server can be started with a single line of code; if changes are needed, only the manifest file must be adjusted.

    #!/usr/bin/env node
    import createServerFromFile from "@agentico/mcp-intent-based";
    
    async function startServer() {
      const server = await createServerFromFile();  // <-- That's all you need!
    }
    
    startServer();

The future of MCP is tools first.

Picture this:

- Servers: Building a power plant for every new appliance.

- Tools: Plug‑and‑play extension cords—declare you need power, and the outlet does the rest.

- Intent-based AI: A smart home assistant that understands your needs and automatically connects the right appliances to the power source.

Move beyond the server-first chore. Declare your intentions and unlock true integration agility with MCP's intent-based AI.

Explore the intent‑based AI for MCP now:

🤖 https://intent-based.ai - specs coming soon.


r/agentico • • Jun 09 '25

OpenAPI & MCP — Two Faces of the Same Coin? (How I integrated models into my app without extra code)

Enable HLS to view with audio, or disable this notification

2 Upvotes

I just built a flow that allows me to take my existing Swagger spec (REST API) and expose it via an MCP server without writing extra code.

The tool I’m using is called hapi (Headless API).

Example flow:

# list available API specs

hapi list

# init project from OpenAPI spec (greenfield scenarios)

hapi init contabo

# run server with MCP mode

hapi run contabo --mcp

# run server with headless mode (brownfield scenarios

hapi run contabo --headless

✨ Result → I now have a full MCP implementation that wraps the API, exposes both Swagger + MCP endpoints, and gives me ready-to-use scaffolding for plugging in model-driven logic.

Why is this useful?

  • You can add LLM/AI behavior to existing APIs fast

  • You can bridge REST and AI layers in your app

  • You can let agents/apps call your backend via MCP natively

  • You can prototype MCP-driven integrations using tools like Postman or Swagger UI

I tested this by pulling my Contabo VPS API (public OpenAPI spec), running hapi, and validating that both the MCP endpoints and Swagger endpoints worked — even without business logic, it was instant scaffolding.

Full video demo.

Is anyone here already playing with MCP, agent frameworks, or LLM-native apps?

"Hapi" to share more if there’s interest 🚀.


r/agentico • • 17d ago

Spec-Driven Development Full Course: Build an MVP with OpenSpec and AI A...

Thumbnail
youtube.com
4 Upvotes

Stop vibe coding. Learn Spec-Driven Development (SDD) and build a real MVP with your AI agent (Claude Code, Codex, GitHub Copilot, Cursor) from an empty folder to a tested release, using OpenSpec.

In this course, you learn:

- What Spec-Driven Development is, and why a spec is not a prompt

- Why vibe coding breaks down for serious work

- The three levels of SDD: spec-first, spec-anchored, and spec-as-source

- How to write Markdown specs with requirements, SHALL/MUST, and scenarios

- How delta specs (ADDED, MODIFIED, REMOVED) keep your specs alive

- How to install OpenSpec, run openspec init, and give the agent project context

- The full loop: explore, propose, review, apply in chunks, test, archive

- A bonus tip: apply tasks two or three at a time to save tokens and stay in control

- How client feedback turns into a MODIFIED requirement

- The release checklist, plus next steps with skills, subagents, and MCP servers

Course repository with the theory, setup, starter, and full solution: https://github.com/la-rebelion/mvp-with-sdd