DEV Community: tercel

"Bridging the Terminal Gap: Instant CLI Tools for the Agentic Era"

tercel — Sat, 28 Mar 2026 06:39:20 +0000

If you’re building AI Agents, you probably spend a lot of time in two places: the LLM’s chat window and your terminal.

One of the most frustrating parts of Agent development is the "Black Box" problem. Your Agent calls a tool, the tool fails, and you’re left digging through logs to understand why. Was it the parameters? The environment? Or the tool logic itself?

At apcore, we believe that if a module is "AI-Perceivable," it should also be "Developer-Perceivable." This is why we prioritize terminal accessibility as a first-class citizen of our ecosystem.

In this fourth article of our series, we move from high-level vision to the terminal, showing how you can instantly transform any apcore module into a powerful CLI tool for human debugging and system interaction via apcore-cli.

Convention-over-Configuration (§5.14)

The "Zero Import" way to build CLI tools is one of the most powerful features of apcore-cli. By using the ConventionScanner from the apcore-toolkit, apcore-cli can turn a directory of plain Python files into a professional terminal application.

No base classes. No decorators. No imports from apcore. Just functions with PEP 484 type hints.

# commands/deploy.py
def deploy(env: str, tag: str = "latest") -> dict:
    """Deploy the app to the given environment."""
    return {"status": "deployed", "env": env}

By dropping this file into a commands/ directory, apcore-cli automatically:

Infers the input_schema and output_schema from the type hints.
Generates the CLI command: apcore-cli deploy deploy --env prod.
Provides the --help text from the function's docstring.

Deep Dive: The Magic of Reflection

The apcore-cli tool uses the Registry to discover all available modules and their schemas. It then uses reflection to map Canonical IDs directly to subcommands.

For example, if you have a module with the ID executor.email.send_email, apcore-cli will automatically generate the following command structure:

$ apcore-cli executor email send-email --to "dev@example.com" --subject "Hello" --body "World"

Boolean Flag Pairs & Enum Choices

Because every apcore module must have an input_schema, the CLI doesn't guess. It uses that schema to:

Generate --verbose / --no-verbose pairs for boolean fields.
Provide shell-validated enum choices (e.g., --format json) from JSON Schema enum properties.
Enforce required fields, showing them as [required] in the --help text.

STDIN Piping (The Unix Way)

A module in apcore is a universal unit of functionality. By exposing your modules via a CLI, you gain the power of Unix pipes. You can pipe JSON input directly into a module, and CLI flags will override specific keys:

# Pipe JSON input and override a parameter
echo '{"a": 100, "b": 200}' | apcore-cli math.add --input - --a 999
# {"sum": 1199}

# Chain with other tools
apcore-cli sysutil.info | jq '.os, .hostname'

TTY-Adaptive Output

One of the most powerful features of apcore-cli is its ability to adapt its output based on the environment. If you’re in a terminal (TTY), it renders a rich, human-readable table. If you’re in a pipe, it outputs raw JSON for further processing.

This makes apcore-cli the perfect tool for developers to debug their Agent's skills and for sysadmins to automate their workflows.

Conclusion: Bridging the Gap

Reliable AI systems are built by developers who can "see" what their Agents are doing. apcore-cli bridges the gap between the terminal and the LLM, giving you a shared interface to inspect, test, and control your AI-Perceivable modules.

Now that we’ve mastered the terminal, it’s time to go back to the Agentic workforce. In the next article, we’ll dive into apcore-a2a: How Agents use these same modules to collaborate autonomously.

This is Article #4 of the **apcore: Building the AI-Perceivable World* series. Join us in making the terminal a first-class citizen of the Agentic Era.*

GitHub: aiperceivable/apcore-cli

"The Missing Link in the Agent Stack: Why apcore is the Foundation for MCP"

tercel — Sat, 28 Mar 2026 06:00:15 +0000

If you’ve been following the AI Agent space recently, you’ve likely been hit with a wave of acronyms and frameworks. Anthropic released MCP (Model Context Protocol). OpenAI has Structured Outputs. LangChain and LlamaIndex have their own tool ecosystems.

It’s natural to feel overwhelmed. "Do I really need another standard? Shouldn't I just use MCP?"

The answer isn't about choosing one over the other. It’s about understanding the Agent Stack. In this third article of our series, we’ll demystify the ecosystem and show why apcore is the foundational "missing link" that provides the kernel for transport protocols like MCP.

Defining the Agent Stack

To understand where we fit, we need to categorize these technologies by the problem they solve:

The Orchestrator (The Brain): Examples: LangChain, CrewAI.
- Focus: Chaining calls and reasoning logic.
The Transport (The Pipe): Examples: MCP, OpenAI Tools.
- Focus: How the message moves from the LLM to the code.
The Module Standard (The Kernel): Example: **apcore.
- Focus: How the module is built, secured, and perceived inside the server.

Why MCP Needs a Module Standard

Anthropic’s MCP is a brilliant transport protocol. It tells you how to send a request between a client (like Claude) and a server. But it doesn't tell you how to structure the code inside that server. It doesn't provide built-in ACL, cross-language consistency, or a secured execution pipeline.

This is where apcore provides the "Soul" for the MCP "Body."

Real-World Integration: apcore-mcp

To demonstrate this synergy, we built apcore-mcp. It is a zero-intrusion adapter that scans your apcore modules and projects them as MCP tools automatically.

By using apcore as your internal standard, you get:

Display Overlays (§5.13): Aliasing internal module IDs to Agent-friendly names (e.g., executor.user.get -> get_user_info) without changing code.
Zero-Intrusion Adapters: You build your logic once, and it instantly works with Claude Desktop, Cursor, or any MCP-compliant client.

Schema Conversion & OpenAI Compatibility

LLMs are picky about JSON Schemas. OpenAI’s "Strict Mode," for example, requires additionalProperties: false and specific handling of optional fields.

apcore-mcp includes a sophisticated SchemaConverter. It automatically:

Inlines $ref pointers: Ensuring the LLM gets a self-contained schema.
Strict Mode Support: For OpenAI tools, it ensures all properties are required (making optional ones nullable) to guarantee structured outputs.
Annotation Mapping: It maps apcore-specific annotations like readonly and destructive to MCP ToolAnnotations, giving the model a "cognitive hint" about the operation's safety.

The Tool Explorer: Interactive Debugging

Building AI tools shouldn't be a "blind" process. When you run apcore-mcp with the --explorer flag, it launches a browser-based UI.

The Tool Explorer allows you to:

Browse Schemas: See exactly how the AI perceives your tools.
Interactive Testing: Execute tools directly from the browser with a Swagger-UI-style interface.
JWT Debugging: Test your secure modules by providing Bearer tokens directly in the UI.

Conclusion: The Backbone of Your MCP Strategy

By using apcore-mcp, you aren't just building an MCP server; you are building a standardized, AI-Perceivable workforce. You get the flexibility of MCP with the rigor and governance of the apcore standard.

Next, we’ll move to the terminal and look at apcore-cli: How to turn your AI skills into professional admin tools using "Convention-over-Configuration."

This is Article #3 of the **apcore: Building the AI-Perceivable World* series. Join us in standardizing the future of AI interaction.*

GitHub: aiperceivable/apcore-mcp

The "Cognitive Interface": Beyond UI and API

tercel — Fri, 27 Mar 2026 12:46:02 +0000

For decades, software engineering has focused on two primary interfaces:

User Interface (UI): Optimized for human perception—visual, intuitive, and interactive.
Application Programming Interface (API): Optimized for machine perception—structured, typed (REST, gRPC), and deterministic.

But as we enter the era of Autonomous Agents, a massive gap has appeared. An AI Agent is neither a human nor a traditional program. It is a Cognitive Caller. It doesn't just need to know what endpoint to hit; it needs to perceive the intent, behavior, and constraints of the code it’s about to invoke.

In this second post of our apcore series, we explore the rise of the Cognitive Interface and why it’s the third essential layer of the modern software stack.

The Perception Gap

Traditional APIs are built for compilers and human developers. When a developer uses an API, they read documentation, understand the edge cases, and write code to handle them. When a machine calls another machine via gRPC, it relies on strict binary contracts.

AI Agents operate differently. They "perceive" your system through a semantic lens. If your API lacks a Cognitive Interface, the Agent has to "hallucinate" the context.

To be truly AI-Perceivable, a module must pass through three stages of cognition:

Perception: "I see a tool exists that claims to handle 'Payments'."
Understanding: "I understand that this tool is destructive, requires mfa_approval, and should not be used for amounts over $500."
Execution: "I can generate the correct JSON schema and handle the structured error if the balance is insufficient."

Why Swagger/OpenAPI Isn't Enough

Many developers think, "I already have Swagger docs, isn't that a Cognitive Interface?"

Not exactly.

Swagger (OpenAPI) was designed for humans to read and for tools to generate client SDKs. It lacks the behavioral semantics that an AI needs to make autonomous decisions.

Does Swagger tell an Agent that a specific endpoint is "expensive" or "slow"?
Does it explain "common mistakes" or "when NOT to use" this tool?
Does it provide "AI-specific guidance" on how to recover from a 403 error?

A true Cognitive Interface, as defined by the apcore standard, provides a semantic layer that wraps the technical API.

The Architecture of a Cognitive Interface

In apcore, we implement the Cognitive Interface through a system of Progressive Disclosure. We don't overwhelm the LLM's context window with every detail at once.

1. The Discovery Layer (`description`)

A short, 100-character string. This is the "index" the AI uses to find candidate tools.
Example: "Send encrypted emails via ProtonMail API."

2. The Planning Layer (`annotations`)

Structured metadata that tells the AI about the "personality" of the code.
Example: readonly=False, destructive=True, requires_approval=True.

3. The Cognition Layer (`documentation`)

Detailed, Markdown-ready documentation that the AI only reads after it has selected the tool for a task. This includes usage examples, business constraints, and pitfalls.

# A Cognitive Interface in apcore (Python)
class FinancialTransferModule(Module):
    description = "Transfer funds between internal accounts."

    documentation = """
    ## Constraints
    - Maximum transfer: $10,000 per transaction.
    - Requires 'finance_admin' role in the context.
    - Post-condition: Both account balances are updated atomically.

    ## Common Mistakes
    - Don't use this for external wire transfers; use `executor.wire.transfer` instead.
    """

    annotations = ModuleAnnotations(
        destructive=False,
        requires_approval=True, # Critical cognitive stop-sign
        cacheable=False
    )

Closing the "Translation Tax"

Currently, enterprise AI integration suffers from a heavy Translation Tax. Developers spend thousands of hours manually writing "tool wrappers" and "system prompts" to explain their APIs to LLMs.

When you build with an AI-Perceivable standard like apcore, you eliminate this tax. The module is the documentation. The schema is the contract. The annotations are the governance.

As we move toward "Agentic Operating Systems," the Cognitive Interface will become as fundamental as the UI is for Windows or the API is for the Web.

What’s Next?

In our next article, we address the elephant in the room: How does apcore relate to MCP (Model Context Protocol) and LangChain? Is it a competitor or the missing foundation?

Stay tuned.

This is Article #2 of the **apcore: Building the AI-Perceivable World* series. Join the movement toward structured AI-machine interaction.*

GitHub: aiperceivable/apcore

Why Your AI Agent Keeps Calling the Wrong Tool (and How to Fix It)

tercel — Thu, 26 Mar 2026 12:53:58 +0000

Why Your AI Agent Keeps Calling the Wrong Tool (and How to Fix It)

It’s Friday afternoon. You’ve just deployed a sophisticated AI Agent with a suite of 50 enterprise tools. Five minutes later, the logs show a disaster: the Agent was supposed to deactivate_user for a support ticket, but instead, it hallucinated and called delete_user.

Why? Because the text descriptions were "too similar," and the LLM felt lucky.

If you’ve spent any time building Agentic systems in 2024 or 2025, you know this pain. We’ve been building mission-critical automation on top of "Vibes"—fuzzy string descriptions and loose JSON objects.

In this first post of our series on apcore, we’re going to look at why traditional tool-calling is failing and how we can move toward a world of AI-Perceivable modules.

The "Vibe-Based" Engineering Crisis

Today, most AI tools are defined like this (OpenAI/LangChain style):

{
  "name": "delete_user",
  "description": "Removes a user from the system permanently.",
  "parameters": {
    "type": "object",
    "properties": {
      "user_id": { "type": "string" }
    }
  }
}

On the surface, this looks fine. But as your system scales from 5 tools to 50 or 500, several critical failure points emerge:

Description Overlap: If you have remove_user, delete_account, and deactivate_member, the LLM often picks the wrong one based on a slight nuance in the user's prompt.
No Behavioral Context: Does the AI know that delete_user is a destructive operation that should require human approval? No. It just sees a string.
The Validation Gap: Traditional tools are often "fire and forget." If the AI passes a malformed ID, the system throws a generic 500 error, and the Agent gets stuck in a loop.

We are essentially trying to "Prompt Engineer" our way into reliable software. That is not engineering; that’s hope.

Introducing apcore: The AI-Perceivable Standard

At apcore, we believe that if a module is to be invoked by an AI, it must be AI-Perceivable. This means the module must explicitly communicate its structure, its behavior, and its constraints in a way that the AI doesn't have to "guess."

Let's look at the same delete_user tool implemented as an apcore module in Python:

from apcore import Module, ModuleAnnotations, Context
from pydantic import BaseModel, Field

class DeleteUserInput(BaseModel):
    user_id: str = Field(..., description="The unique UUID of the user to be deleted.")

class DeleteUserModule(Module):
    # Core Layer: Mandatory Schema
    input_schema = DeleteUserInput
    description = "Permanently deletes a user and all associated data."

    # Annotation Layer: Behavioral Guidance
    annotations = ModuleAnnotations(
        readonly=False,
        destructive=True,        # The AI now knows this is dangerous
        requires_approval=True, # The system will enforce a human gate
        idempotent=False
    )

    def execute(self, inputs: dict, context: Context) -> dict:
        # Logic goes here...
        return {"status": "success"}

Why this is a game-changer:

Dual-Layered Intelligence: We separate the description (short, for discovery) from the documentation (long, for detailed planning). The AI only reads the "manual" when it's actually considering using the tool.
Behavioral Guardrails: By marking a module as destructive, we give the LLM a cognitive "stop sign." It knows it shouldn't just run this autonomously.
Strict Enforcement: In apcore, you cannot register a module without a valid schema. It turns "AI-Perceivability" from a best practice into a protocol requirement.

The Secret Sauce: `ai_guidance`

What happens when the AI does make a mistake? In traditional systems, you get a traceback. In apcore, we use Self-Healing Guidance.

If an Agent sends a numeric ID instead of a UUID to our delete_user module, apcore doesn't just crash. It returns a structured error:

{
  "code": "SCHEMA_VALIDATION_ERROR",
  "message": "Input validation failed",
  "ai_guidance": "The user_id must be a UUID format (e.g., 123e4567-e89b-12d3-a456-426614174000). Please check the user record and try again."
}

The Agent reads the ai_guidance, realizes its mistake, fetches the correct UUID, and retries—autonomously. This is the path to truly resilient Agentic systems.

Conclusion: Stop Prompting, Start Engineering

We need to stop treating AI tools as "text snippets" and start treating them as first-class citizens of our software architecture. Reliability doesn't come from a "better prompt"; it comes from enforced standards.

apcore provides that standard. Whether you are building in Python, TypeScript, or Rust, apcore ensures that your interfaces are naturally understood and safely invoked by any AI.

In the next article, we’ll dive into the "Cognitive Interface"—why the way AI perceives your code is fundamentally different from how a human or a compiler does.

This is Article #1 of the **apcore: Building the AI-Perceivable World* series. Follow us for a deep dive into the future of Agentic standards.*

GitHub: aiperceivable/apcore

The Year AI Changed Everything: 8 Defining Moments of 2025

tercel — Thu, 19 Mar 2026 09:50:32 +0000

2025 wasn't just another year of incremental AI progress — it was the year AI became infrastructure.

Reasoning models that think before they speak. Coding agents that ship production code. Open-source models that rival closed APIs. If you blinked, you missed a paradigm shift.

I've been tracking these developments all year, and I want to distill the noise into the 8 moments that actually mattered — and what they mean for developers heading into 2026.

1. Claude 4 and the Rise of Agentic AI

Anthropic's Claude 4 family (Sonnet 4, Opus 4) introduced extended thinking — models that reason internally before responding, with the thinking process visible to developers.

But the real story was Claude Code. By mid-2025, it became the dominant AI coding tool — not because of better autocomplete, but because it operated as a genuine coding agent: reading entire codebases, running tests, fixing CI failures, and opening PRs autonomously.

# This became a real workflow in 2025
claude "refactor the auth module to use JWT, update all tests, and open a PR"
# ...and it actually worked.

The 1M token context window meant Claude could hold an entire mid-size codebase in memory, making "just read the whole repo" a viable prompting strategy.

Why it matters for developers: The gap between "describe what you want" and "get a working PR" collapsed. AI moved from assistant to collaborator.

2. GPT-5 and OpenAI's Pivot to Agents

OpenAI shipped GPT-5 with significantly improved reasoning, but the bigger story was their ecosystem play:

Deep Research — autonomous browsing, synthesis, and multi-page report generation
Codex CLI — a terminal-first developer workflow tool
ChatGPT as an OS — managing tasks, executing code, and maintaining context across sessions

The "agents" narrative shifted from marketing buzzword to shipping product.

# OpenAI's Agents SDK made autonomous workflows accessible
from openai import Agent

agent = Agent(
    model="gpt-5",
    tools=[web_search, code_interpreter, file_manager],
    instructions="Research and summarize the top 10 AI papers this week"
)
result = agent.run()

Why it matters for developers: Agent frameworks are no longer experimental. They're production infrastructure — with SDKs, error handling, and tool ecosystems.

3. Gemini 2.5 Pro: Google's Multimodal Bet

Google's Gemini 2.5 Pro arrived with native multimodal reasoning — not "vision bolted onto a language model," but genuinely integrated understanding of text, images, audio, and video in a single inference pass.

The 1M token context matched Claude, but Google's integration advantage was the killer feature: Gemini in Android, in Search, in Workspace. Google embedded AI into the daily workflow of billions of users — not just developers.

# Gemini CLI brought terminal-native AI to Google's ecosystem
gemini "analyze this codebase and suggest performance improvements"

Why it matters for developers: Multimodal isn't a feature — it's a new input paradigm. Applications can now accept screenshots, voice notes, and documents as first-class inputs.

4. The Open Source Explosion

2025 was the year open-source AI crossed from "impressive demos" to production-ready alternatives:

Model	Org	Key Achievement
Llama 4	Meta	Frontier-class reasoning, open weights
DeepSeek R1/V3	DeepSeek	Chain-of-thought rivaling GPT-4o at a fraction of the cost
Qwen 3	Alibaba	Multilingual excellence, especially CJK languages

The economics shifted dramatically. A single A100 running DeepSeek V3 could handle workloads that previously required frontier API calls.

# Running frontier-quality models locally became normal
ollama run deepseek-r1:70b
# Cost: electricity. Latency: milliseconds. Privacy: absolute.

Why it matters for developers: "Local AI" went from hobbyist curiosity to legitimate infrastructure choice. You can now build AI features with zero API dependencies.

5. The AI Coding Revolution

By Q3 2025, the question wasn't "do you use AI for coding?" but "which AI coding tool do you use?"

The market crystallized around four approaches:

Claude Code — agent-first, terminal-native, ships entire features autonomously
Cursor — IDE-integrated, context-aware, best for interactive pair programming
GitHub Copilot — ubiquitous, deeply integrated into VS Code and GitHub
Gemini CLI / Codex CLI — terminal tools from Google and OpenAI

Teams reported 2-5x throughput increases on well-scoped tasks. But the more interesting finding: AI coding tools didn't just make developers faster — they changed what developers chose to build. Projects that would have been "too much boilerplate" became viable.

The flip side was uncomfortable: junior developer hiring slowed as companies realized AI could handle tasks traditionally assigned to entry-level engineers. The industry hasn't yet figured out how to train the next generation when the learning-by-doing work is being automated.

Why it matters for developers: If you haven't integrated AI coding tools into your workflow yet, you're leaving significant leverage on the table. Pick one and go deep.

6. Multimodal AI Goes Mainstream

Three breakthroughs converged:

Native image generation. GPT-4o gained the ability to generate and edit images mid-conversation. No more switching tools — say "diagram this architecture" and get a coherent visual inline.

Video generation. Sora and Google's Veo 2 made AI video practical — not perfect, but good enough for prototypes, social content, and educational materials.

Audio AI. Google's NotebookLM turned any document into a podcast-style discussion. The "AI podcast" format exploded, with millions of auto-generated audio summaries appearing across platforms.

Why it matters for developers: The text-in, text-out era is ending. Users will expect your applications to understand and generate images, audio, and video natively.

7. AI Regulation Takes Shape

2025 was the year regulation went from theoretical to operational:

EU AI Act — enforcement began, requiring risk classification, transparency documentation, and human oversight mechanisms
US Executive Orders — new frameworks for safety testing of frontier and autonomous systems
China's AI Governance — expanded rules requiring watermarking and content moderation

The developer impact was immediate: if you shipped AI features in the EU, you now needed compliance infrastructure. "Move fast and break things" met "fill out this compliance form first."

Why it matters for developers: Compliance is now a feature, not an afterthought. Build transparency and audit trails into your AI systems from day one.

8. MCP: The USB-C of AI

Anthropic's Model Context Protocol (MCP) might be the most consequential infrastructure play of 2025. It standardized how AI models interact with external tools — databases, APIs, file systems, dev environments.

Before MCP, every AI integration was bespoke. After MCP, you write a tool server once and it works with Claude, VS Code, JetBrains, and any MCP-compatible client.

// A simple MCP tool server — write once, use everywhere
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

const server = new McpServer({ name: "my-tool" });

server.tool(
  "query_database",
  { sql: z.string() },
  async ({ sql }) => {
    const result = await db.query(sql);
    return {
      content: [{ type: "text", text: JSON.stringify(result) }]
    };
  }
);

By year-end, MCP became the de facto standard. Not the flashiest announcement of 2025, but potentially the one with the most lasting impact — protocols outlive products.

Why it matters for developers: If you're building AI integrations, build on MCP. It's the closest thing we have to a universal connector for AI tooling.

Looking Ahead: What 2026 Holds

If 2025 was "AI becomes infrastructure," 2026 will be "AI becomes invisible."

Four predictions:

Agent-to-agent communication will standardize. Your coding agent will negotiate with your CI/CD agent, which coordinates with your monitoring agent.
AI-native applications — built around AI from day one, not AI bolted onto existing apps — will start displacing incumbents.
The cost curve continues. Frontier-quality inference will get 10x cheaper, making AI features viable where the economics didn't work in 2025.
Developer tooling consolidates. The 50 different AI coding tools will narrow to 3-4 winners along terminal-native vs. IDE-integrated vs. cloud-hosted lines.

The one thing I'm most certain of: 2025 was not the peak. It was the foundation.

What was your biggest AI moment of 2025? I'd love to hear what shifted your workflow the most — drop a comment below.

If you found this useful, consider following for more deep dives on AI tooling and developer workflows.

The Iron Law of TDD — Trusting AI with Professional-Grade Code

tercel — Wed, 18 Mar 2026 13:50:28 +0000

"AI code is buggy." Correction: Unverified AI code is buggy.

If you aren't using Code-Forge, you're playing Russian Roulette with your production branch. 💻

The Wall: Why Autocomplete Isn't Enough
Standard AI completions often hallucinate. They don't know if your tests pass, and they don't care about your project's performance.

The Code-Forge Workflow: RED → GREEN → REFACTOR
code-forge is a skill that enforces the TDD cycle autonomously:

Red Phase: It writes a failing test first.
Green Phase: It writes the minimal implementation to pass.
Review Phase: It performs a 14-dimension code review (Security, Performance, Error Handling, etc.) before finishing.
Evidence-Based Verification
With Sub-agent Isolation, every task is handled in a focused session. The AI only claims completion once it reads the REAL terminal output of a successful test run.

Stop guessing. Start Forging. ⚡🔥

🛠️ Open Source AI Skills
All the Skills mentioned in this series (spec-forge, code-forge, hype-forge, etc.) are open-source and available on GitHub. They are compatible with Gemini CLI and Claude Code:

👉 GitHub Repository: tercel/tercel-claude-plugins (Give it a Star if you find it useful!)

Docs-as-Code: Automating Architecture with Spec-Forge

tercel — Mon, 16 Mar 2026 11:53:36 +0000

Technical debt often starts with missing or outdated documentation. In the AI era, documentation isn't just for humans—it's the blueprint for the AI.

Why Traditional Specs Fail
Standard PRDs are too vague. They don't provide the method signatures or logic flows an AI needs to be accurate.

The Spec-Forge Workflow
spec-forge is a professional skill that bridges the gap between idea and implementation:

Deep Repo Scanning: It identifies your existing patterns so the design is "native" to your project.
Mermaid C4 Diagrams: Visualizing containers and components as code.
Implementable Specs: It generates high-granularity feature docs that AI coding tools (like code-forge) can execute without guessing.
Stop treating design as an afterthought. Let the AI help you architect a better system. 🏗️

👉 GitHub Repository: tercel/tercel-claude-plugins (Give it a Star if you find it useful!)

Stop Prompting, Start Forging: A New Era of Professional SDLC

tercel — Fri, 13 Mar 2026 13:17:53 +0000

We’ve all been there: asking a LLM to implement a complex feature, only to get a 200-line solution that fails immediately.

The problem isn't the AI's intelligence. It's the Medium. A chat window is a silo. It has no hands, no terminal, and no memory.

The "Manual Prompting" Tax
Prompting is the new manual labor. You are the one syncing files and running tests. This is high-friction and error-prone.

Skills change the game by giving the AI a "Body": the ability to read, write, and execute in your local environment.

The Forging Stack
Spec-Forge: Automated Technical Design.
Code-Forge: Autonomous TDD Execution.
Hype-Forge: Technical Advocacy and Content.
We move from "I think it works" to "The terminal says it works." 🚀

👉 GitHub Repository: tercel/tercel-claude-plugins (Give it a Star if you find it useful!)

Stop Building "AI Tools"—Start Building "Cognitive Interfaces": A New Standard for the Agent Era

tercel — Wed, 11 Mar 2026 12:36:17 +0000

The AI ecosystem is currently in a chaotic "pre-HTTP" era.

We are all hand-coding JSON schemas, bespoke MCP servers, and fragile wrappers. It’s a mess of "glue code" that breaks the moment a function signature changes. But as AI moves from simple chat to autonomous action, "glue code" isn't enough. We need a foundation.

Enter apcore — the universal framework for the Cognitive Interface era.

It doesn't just "connect" tools; it redefines how software is perceived and safely invoked by AI, reducing token bloat by 90% and enabling self-healing agents.

The Problem: The "Documentation Gap"
Traditional modules are built for code-to-code interaction. They lack the Intent and Semantic Metadata that AI needs to make autonomous decisions.

When you manually wrap functions for OpenAI or Claude, you create a maintenance nightmare:

Schema Drift: Change a function signature, and your JSON Schema breaks.
Context Blindness: The LLM doesn't know if a tool is "destructive" or "read-only" until it's too late.
Token Bloat: Sending massive documentation for 50 tools wastes context and money.
The Solution: apcore (AI-Perceivable Core)
apcore is not just another wrapper. It’s a universal development framework that enforces a "Schema-First" approach. It defines the Cognitive Interface — a standardized way for AI to discover, understand, and safely invoke code.

[ Application Layer ] Django / Flask / NestJS / Legacy Systems
|
[ Core Layer ] apcore (Registry & Executor)
|
[ Protocol Layer ] /------|------\
MCP A2A OpenAI / Tools
| |
[ AI Layer ] Claude Agents GPT-4o

The 4 Integration Paths (Zero to Native) apcore is designed for progressive adoption. You don't need to rewrite your app:

Path Invasiveness Use Case
Class-based High New, heavy-duty modules with complex validation.
@module Decorator Low One-line change to existing Python/TS functions.
module() Call Very Low Wrap existing methods without touching source code.
YAML Binding Zero Map legacy or 3rd-party code using apcore-toolkit.

Progressive Disclosure: Saving your Token Budget apcore uses a Three-Layer Metadata design inspired by Claude's Skill standards. This allows for Progressive Disclosure:

Discovery Phase: AI only reads the description (≤200 chars).
Decision Phase: AI fetches the full documentation and input_schema only for candidate tools. Result: Up to 90% reduction in initial token consumption for large toolsets.

Self-Healing Agents with ai_guidance Standard errors are for programs. apcore introduces ai_guidance. When a tool fails, the framework doesn't just return a stack trace; it provides a human-readable hint telling the Agent how to fix the error and retry.

The apcore Ecosystem
apcore is the foundation for a suite of specialized adapters:

[apcore-mcp]: Instantly turn your modules into an MCP Server for Claude Desktop or Cursor.
[apcore-a2a]: The future of Agent-to-Agent communication. Expose your logic as a standards-compliant A2A server.
[apcore-toolkit]: The "Migration Engine." Automatically scan your Django/Flask/Express projects and generate apcore bindings.
Enterprise Safety: NIST 2026 Compliance
Security isn't an afterthought. apcore is built to address the 2026 U.S. Federal Government RFI on AI Agent Security:

Default-Deny ACL: Pattern-based access control. api.* can call orchestrator.*, but never executor.db_delete directly.
Human-in-the-Loop (HITL): Modules tagged with requires_approval=True trigger mandatory safety gates.
Auditability: W3C-compliant trace_id propagation tracks the entire "trajectory" of an agent's decisions across your stack.
Quick Start (Python)
from apcore import module

@module(
id="calculator.add",
description="Add two integers",
annotations={"readonly": True}
)
def add(a: int, b: int) -> int:
return a + b

Expose to Claude via MCP in one command:

pip install apcore-mcp

python -m apcore_mcp --extensions-dir ./modules

Conclusion
Building for AI shouldn't mean double the work. With apcore, you build once and invoke via Code, CLI, REST, MCP, or A2A.

Stop writing glue code. Start building the Cognitive Interface.

GitHub: https://github.com/aipartnerup Docs: https://apcore.aipartnerup.com/ SDKs: Available in Python and TypeScript with identical semantics.

Stop Writing Glue Code: Build AI-Perceivable Modules with apcore

tercel — Mon, 02 Mar 2026 14:27:11 +0000

AI Agents are only as good as the tools they can use. But why is it so hard to connect our code to an LLM?

Right now, the ecosystem is fragmenting. Everyone is building custom MCP servers or manually writing massive JSON schemas just to let an AI call a simple Python function. In this post, I'll introduce apcore, a new framework designed to solve the root cause of the "AI Integration" problem.

The Problem: The "Documentation Gap"
Traditional modules are built for code to call, not AI. AI Agents need Schema and Intent. When we manually map our functions to JSON schemas for OpenAI or Anthropic, we create a maintenance nightmare.

The Solution: apcore
apcore is a universal module development framework that enforces a "Schema-First" approach. Every module you build becomes inherently AI-Perceivable.

It’s not just a wrapper—it's a complete protocol with identical SDKs in Python and TypeScript.

[ Application Layer ]   Django / Flask / NestJS / Tiptap ...
                               |
[   Core Layer    ]     apcore (Capability Registry & Executor)
                               |
[ Protocol Layer  ]     /------|------\
                     MCP      A2A    Future-Protocols
                      |        |
[    AI Layer     ]  LLMs   Other-Agents

4 Ways to Integrate
The best part? You don't have to rewrite your app. You have four options:

The Decorator (1-line change): Add @module(id="email.send") to a function, and apcore infers the JSON schema from your type hints.
The Function Call: Pass an existing method to module(service.send) without touching the source code.
YAML External Bindings (Zero Code): Have a massive legacy system? Write a YAML file to map it to apcore. Zero code modification.
Class-based Modules: For heavy-duty tools with complex validation.
Truly Protocol Agnostic
Once you build an apcore module, you standardize how your logic is described. This makes it natively compatible with:

MCP (Model Context Protocol): Expose it to Claude or Cursor with zero work.
A2A (Agent-to-Agent): Ready for standardized cross-agent tool calls.
OpenAI Tools: Export standard tool definitions for ChatGPT or custom assistants.
REST/CLI: Your logic is also a web API or a command-line tool by default.
Three-Layer Metadata
apcore gives AI everything it needs to know:

Core Layer: input_schema, output_schema, and description.
Annotation Layer: Type-safe behavioral flags. Add destructive=True or requires_approval=True to a module, and the AI will know it shouldn't execute it without asking the user first.
Extension Layer: LLM intent hints (like x-when-to-use).
The Execution Pipeline (Enterprise Safety)
apcore isn't just about schemas; it manages execution. Every tool call goes through:

Default-Deny ACL: e.g., only allow api.* modules to call executor.* modules. Prevent AI agents from accidentally going rogue in your backend.
Onion-Model Middleware: Easily add custom hooks for caching or rate-limiting.
Context & Tracing: A Context object propagates W3C trace_id across your entire call chain.
🚀 The "Zero Glue Code" Multiplier: apcore-mcp
While apcore is protocol-neutral, we provide first-class bridges. apcore-mcp turns your apcore registry into a full Model Context Protocol (MCP) server instantly:

pip install apcore-mcp
python -m apcore_mcp --extensions-dir ./your_modules
Boom. You have an MCP server, complete with a built-in Tool Explorer UI.

🛡️ Built for the Future: NIST 2026 RFI Compliance
Security isn't an afterthought in apcore; it's the foundation. Our framework is one of the first to provide a production-ready implementation for the 2026 U.S. Federal Government RFI on AI Agent Security.

Here is how apcore maps to the NIST requirements:

Blast Radius Control: Use our pattern-based ACL to ensure agents only access the specific tools they need (Least Privilege).
Human-in-the-Loop (HITL): Modules annotated with requires_approval=True automatically trigger safety gates for high-impact actions.
Auditability: Every agent action is logged and traced with a W3C-compliant trace_id, allowing you to reconstruct the exact "trajectory" of an agent's decisions.
Input/Output Validation: Mandatory schemas act as a firewall, preventing prompt injection from turning into malicious tool parameters.
Conclusion
Building for AI shouldn't mean double the work—or double the risk. With apcore, you standardize how your modules are built, and expose them anywhere safely.

Check out the docs: https://apcore.aipartnerup.com/
GitHub: https://github.com/aipartnerup
Python SDK: https://github.com/aipartnerup/apcore-python
TypeScript SDK: https://github.com/aipartnerup/apcore-typescript

DEV Community: tercel

"Bridging the Terminal Gap: Instant CLI Tools for the Agentic Era"

Convention-over-Configuration (§5.14)

Deep Dive: The Magic of Reflection

Boolean Flag Pairs & Enum Choices

STDIN Piping (The Unix Way)

TTY-Adaptive Output

Conclusion: Bridging the Gap

"The Missing Link in the Agent Stack: Why apcore is the Foundation for MCP"

Defining the Agent Stack

Why MCP Needs a Module Standard

Real-World Integration: apcore-mcp

Schema Conversion & OpenAI Compatibility

The Tool Explorer: Interactive Debugging

Conclusion: The Backbone of Your MCP Strategy

The "Cognitive Interface": Beyond UI and API

The Perception Gap

Why Swagger/OpenAPI Isn't Enough

The Architecture of a Cognitive Interface

1. The Discovery Layer (description)

2. The Planning Layer (annotations)

3. The Cognition Layer (documentation)

Closing the "Translation Tax"

What’s Next?

Why Your AI Agent Keeps Calling the Wrong Tool (and How to Fix It)

Why Your AI Agent Keeps Calling the Wrong Tool (and How to Fix It)

The "Vibe-Based" Engineering Crisis

Introducing apcore: The AI-Perceivable Standard

Why this is a game-changer:

The Secret Sauce: ai_guidance

Conclusion: Stop Prompting, Start Engineering

The Year AI Changed Everything: 8 Defining Moments of 2025

1. Claude 4 and the Rise of Agentic AI

2. GPT-5 and OpenAI's Pivot to Agents

3. Gemini 2.5 Pro: Google's Multimodal Bet

4. The Open Source Explosion

5. The AI Coding Revolution

6. Multimodal AI Goes Mainstream

7. AI Regulation Takes Shape

8. MCP: The USB-C of AI

Looking Ahead: What 2026 Holds

The Iron Law of TDD — Trusting AI with Professional-Grade Code

Docs-as-Code: Automating Architecture with Spec-Forge

Stop Prompting, Start Forging: A New Era of Professional SDLC

Stop Building "AI Tools"—Start Building "Cognitive Interfaces": A New Standard for the Agent Era

Expose to Claude via MCP in one command:

pip install apcore-mcp

python -m apcore_mcp --extensions-dir ./modules

Stop Writing Glue Code: Build AI-Perceivable Modules with apcore

1. The Discovery Layer (`description`)

2. The Planning Layer (`annotations`)

3. The Cognition Layer (`documentation`)

The Secret Sauce: `ai_guidance`