GitHub Copilot's Hidden Agentic OS: The 4 Layers You Are Missing

Daniel Montes — Sat, 11 Apr 2026 05:39:59 +0000

If your team is treating artificial intelligence coding assistants merely as an "autocomplete on steroids," you are likely leaving 70% of their capabilities untouched.

Recent evolutions in how developers interact with AI have transformed the humble .github folder into a full-fledged Agentic Operating System (OS). It's no longer just a place for a single instruction file; it's a composable, multi-layered ecosystem designed to manage context, enforce security, and execute autonomous workflows.

This introductory article explores the mental model of this Agentic OS and introduces its 4 distinct layers.

The Problem: "Stateless" AI Assistants

The biggest challenge engineering teams face when adopting AI coding assistants is context loss.

When an AI agent is stateless, every prompt requires developers to manually feed it coding standards, framework rules, and project conventions. This leads to inconsistent code, security vulnerabilities, and developer fatigue. Platform engineering teams need a way to ensure their AI agents operate within a governed, deterministic framework.

The Solution: The Agentic OS Architecture

An "Agentic OS" solves this by acting as the business brain for your repository. It manages resources, context, memory, and automated tasks so the AI has continuity and reliability.

Mapping out the .github ecosystem reveals 7 composable primitives structured across 4 functional layers:

1. Layer 1 — Always-On Context

This is the Passive Memory of your assistant. Files like .github/copilot-instructions.md apply to every single prompt automatically.

Use cases: Enforcing universal coding standards, repository naming conventions, and foundational framework rules.

2. Layer 2 — On-Demand Capabilities

This layer introduces specialized tools and memory loaded only when necessary (Progressive Loading). It includes:

Prompt Files: Pre-configured prompts invoked manually via slash commands (e.g., /security-review, /changelog).
Custom Agents: Specialist personas (e.g., a Planning Agent chaining work to an Implementation Agent).
Skills: Repeatable runbooks and incident triage scripts.

3. Layer 3 — Enforcement & Automation

This is where probabilistic LLMs meet deterministic guarantees. This layer introduces structural controls.

Hooks: Deterministic shell commands that trigger at lifecycle events (e.g., preToolUse to approve or deny an action before it executes).
Agentic Workflows: Natural language automations compiled into GitHub Actions for CI failure analysis or issue triage.

4. Layer 4 — Distribution

Once you have built your perfect Agentic OS for a project, you need to scale it.

Plugins: Decentralized packaging allows you to bundle agents, prompts, and skills to share team-specific configurations across the entire enterprise.

What's Next?

Understanding this 4-layer architecture shifts GitHub Copilot from a passive autocomplete tool into an active, governed participant in your software development lifecycle.

In the upcoming articles of this series, we will dive deep into each layer, starting with how to properly configure your Always-On Context to enforce coding standards without overloading the context window. Stay tuned!

Stop pasting broken Markdown into Jira: building md2jira

Daniel Montes — Sun, 05 Apr 2026 05:31:26 +0000

If you write Jira tickets in Markdown, you've probably hit the same problem I did: the moment you paste that text into Jira, the result is inconsistent.

Sometimes you get raw **bold**, # headers, and pipe tables. Sometimes Jira partially formats things. Tables and code blocks usually need manual cleanup.

I built md2jira to make that workflow predictable.

What is md2jira?

md2jira is a monorepo with three independent pieces that share the same conversion engine:

Web previewer (`apps/web`)

A live two-panel editor in the browser. Paste Markdown on the left, get Jira-ready output on the right — instantly, with no backend, no login, and no data sent anywhere.

Use this if: you want to convert Markdown to Jira format right now without installing anything.

Core package (`md2jira-core`)

A pure TypeScript library — zero browser or framework dependencies. It exports two functions:

convert(md) → Jira Wiki Markup string (for Jira Server / Data Center)
convertToAdf(md) → ADF JSON object (for Jira Cloud)

Use this if: you want to integrate Markdown-to-Jira conversion into your own Node.js app, script, or VS Code extension.

CLI (`md2jira-cli`)

A command-line tool that wraps md2jira-core. Reads a Markdown file (or stdin) and writes Jira Wiki Markup to stdout or a file.

Use this if: you want to convert files from the terminal or integrate the conversion into a shell script or CI pipeline.

md2jira input.md                  # stdout
md2jira input.md -o output.txt    # write to file
cat input.md | md2jira            # pipe from stdin

The problem in practice

Here's the difference between pasting raw Markdown directly into Jira and running it through md2jira first:

On the left, Jira gets raw Markdown and leaves it as plain text. On the right, the same content is converted into properly formatted Jira content with headings, emphasis, tables, nested lists, blockquotes, and code blocks.

The web previewer

The web app is designed for people who don't want to install anything. Go to the URL, paste your Markdown, copy the output.

The interface is a split panel:

Left panel: a Markdown editor with line numbers, keyboard shortcuts (Ctrl+B, Ctrl+I, Ctrl+Shift+K, Alt+↑↓…), import/export, and a "Copy MD" button
Right panel: live output with two independent toggles — format (Jira Cloud / Wiki Markup) and view (Preview / Code)

The "Copy for Jira" button is worth highlighting: it writes rich HTML plus plain text to the clipboard at the same time. When you paste directly into Jira Cloud, it renders as formatted content immediately — no manual cleanup needed. This is the main quality-of-life improvement over copying raw text.

What it converts

The core package currently handles:

# Heading → h1. Heading
**bold** → *bold*
_italic_ → _italic_
~~strike~~ → -strike-
`inline code` → {{inline code}}
fenced code blocks → {code} / {code:language=...}
unordered and ordered lists
links, blockquotes, horizontal rules, and tables

Tables were the hardest part. They needed special handling for multiline cells, unequal column counts, escaping pipes inside cells, and inline formatting inside the table content itself.

What turned out to be harder than expected

At first glance, Markdown-to-Jira sounds like a simple string replacement problem. It isn't.

The hardest parts were:

Tables: Jira table syntax is strict, and real Markdown tables are often messy
Clipboard behavior: Jira Cloud reacts differently depending on whether the clipboard contains plain text or rich HTML
ADF vs Wiki Markup: Jira Cloud prefers richer structured content, while Jira Server/Data Center workflows often still rely on Wiki Markup
Keeping the core reusable: packages/core had to stay free of React and browser APIs so it can be reused in a future CLI and VS Code extension

The npm packages

Both packages are published to npm independently:

# Core library — use in your own Node.js/TS projects
npm install md2jira-core

# CLI — convert files from the terminal
npm install -g md2jira-cli

md2jira-core is a pure TypeScript library with zero browser or framework dependencies — it works in Node.js, Deno, Bun, and VS Code extensions. md2jira-cli is a thin wrapper around it that adds file I/O and stdin/stdout support.

Basic usage

import { convert } from 'md2jira-core'

const jira = convert(`
# My Issue

Some **bold** text, _italic_, and ~~strikethrough~~.

| Field  | Value       |
|--------|-------------|
| Status | In Progress |
| Priority | **High**  |

- Item 1
- Item 2
  - Nested item

\`\`\`js
console.log("hello")
\`\`\`

> A blockquote

[Jira Docs](https://confluence.atlassian.com/jira)
`)

console.log(jira)

Output:

h1. My Issue

Some *bold* text, _italic_, and -strikethrough-.

|| Field || Value ||
| Status | In Progress |
| Priority | *High* |

* Item 1
* Item 2
** Nested item

{code:language=js}
console.log("hello")
{code}

bq. A blockquote

[Jira Docs|https://confluence.atlassian.com/jira]

ADF (Atlassian Document Format)

For Jira Cloud, you can also output ADF — the native JSON format that Jira Cloud uses internally:

import { convertToAdf } from 'md2jira-core'

const adf = convertToAdf(`# Hello **World**`)
console.log(JSON.stringify(adf, null, 2))

The web app uses this output to generate the preview and the rich clipboard content used by the "Copy for Jira" action, which is what makes paste into Jira Cloud behave much better than plain text.

How it's built

The conversion pipeline is:

Markdown string
  → remark-parse (AST)
  → transforms/ (visit each node type)
  → Jira Wiki Markup string

Each node type (heading, paragraph, table, list, etc.) has its own transform function in packages/core/src/transforms/. The table transform handles the most edge cases — multiline cells joined with <br>, missing cells padded with empty values, and inline formatting (bold, italic, links, code) inside cells.

The monorepo is structured so that packages/core is 100% framework-agnostic — powering the web app, the CLI (md2jira-cli), and a future VS Code extension.

Tech stack

Layer	Technology
MD Parser	`remark-parse` + `unified`
AST types	`@types/mdast`
UI	React 18 + Vite + Tailwind CSS v4
Testing	Vitest
Package manager	pnpm workspaces

If you work with Jira regularly, give it a try — feedback and PRs are very welcome!

DEV Community: Daniel Montes