Forem: Arthur Palyan

Levels Of Self Launches AI-Powered Business Automation Platform Delivering 40-60% Cost Savings

Arthur Palyan — Thu, 09 Apr 2026 13:32:51 +0000

FOR IMMEDIATE RELEASE

Levels Of Self Launches AI-Powered Business Automation Platform Delivering 40-60% Cost Savings for Service Businesses

Custom AI agents deployed on Telegram, WhatsApp, Instagram, and Facebook for under $500/month

VALENCIA, CA - March 2026 - Levels Of Self, an AI governance and automation company, has launched a business automation platform that deploys custom AI agents on the messaging platforms businesses already use, delivering 40-60% reductions in operational costs for service-based firms.

The platform enables CPA firms, real estate brokerages, law offices, nonprofits, and other service businesses to automate repetitive client interactions - intake, scheduling, follow-up, document collection, and FAQ responses - through AI agents running on Telegram, WhatsApp, Instagram DMs, and Facebook Messenger.

"A 10-person CPA firm with 6 bookkeepers is spending $300,000 a year on work that follows predictable patterns," said Arthur Palyan, founder of Levels Of Self. "We automate 40-60% of that workload with AI agents that run 24/7 on the channels their clients already use. Total cost: under $500 a month."

Platform Capabilities

Each AI agent is custom-built with deep knowledge of the client's industry, services, and communication style. Agents are deployed on up to four messaging platforms simultaneously and governed by the company's open-source Nervous System framework, which provides:

Autonomous monitoring and self-correction
Hash-chained audit trails for compliance
Behavioral rule enforcement at the infrastructure level
Automated quality scoring and continuous improvement

The entire production system - 13 agents across five platforms - runs on cloud infrastructure costing under $500 per month, with those savings passed directly to clients.

Market Opportunity

The platform addresses a growing demand for AI automation among small and mid-size service businesses that lack the technical resources to build and manage AI deployments internally. Unlike enterprise AI platforms that require six-figure implementations, Levels Of Self offers deployment within days at price points starting at $299 per month.

"The businesses that need automation the most are the ones that can least afford enterprise AI pricing," Palyan said. "We built something that works on a single server for under $500 a month. That means a solo practitioner who cannot afford a receptionist can have an AI assistant that works every platform, every hour, every day."

Stripe-Enabled and Live

The platform accepts payments through Stripe with subscription billing active. Businesses can schedule a consultation and begin deployment within the same week.

About Levels Of Self

Arthur Palyan dba Levels Of Self is an AI governance and multi-agent infrastructure company based in Valencia, California. The company combines an open-source governance framework with custom AI agent deployment to help businesses automate operations across messaging platforms. Levels Of Self is SAM.gov registered (CAGE 19R10) and certified as a Small Disadvantaged Business in California.

Contact

Arthur Palyan
Founder, Levels Of Self
ArtPalyan@LevelsOfSelf.com
(818) 439-9770
levelsofself.com
calendly.com/levelsofself/zoom

Valencia-Based AI Governance Company Deploys Nervous System Architecture for Multi-Agent Business Automation

Arthur Palyan — Thu, 09 Apr 2026 13:32:03 +0000

FOR IMMEDIATE RELEASE

Valencia-Based AI Governance Company Deploys Nervous System Architecture for Multi-Agent Business Automation

Levels Of Self delivers open-source AI governance framework while actively pursuing federal and state contracts

VALENCIA, CA - March 2026 - Arthur Palyan dba Levels Of Self, a California-based AI governance and multi-agent infrastructure company, has deployed a production AI governance framework that manages 13 autonomous agents across five messaging platforms while maintaining full audit compliance.

The company's Nervous System, an open-source Model Context Protocol (MCP) server available on npm, provides drift detection, hash-chained audit trails, behavioral rule enforcement, and automated compliance checking for AI agent deployments. The framework currently governs agents operating on Telegram, WhatsApp, Instagram, Facebook Messenger, and web interfaces.

"Everyone in AI is building a bigger brain," said Arthur Palyan, founder of Levels Of Self. "We built the nervous system - the governance layer that makes sure those brains follow the rules. The same pattern recognition methods I used training humans to identify their behavioral loops became the architecture for training AI agents to stay accountable."

Government Readiness

Levels Of Self is registered on SAM.gov (CAGE code 19R10, UEI Q82DA4R75YC3) and certified as a Small Disadvantaged Business in California (SB #2050529). The company holds NAICS codes spanning computer systems design (541511), programming (541512), IT consulting (541519), R&D in physical sciences (541715), and data processing (518210).

The company has active submissions with the Los Angeles Department of Water and Power and the Los Angeles Superior Court, and is pursuing contracts in AI governance compliance, IT modernization, and public safety technology at the state and federal level.

Industry Validation

The deployment comes as major technology companies validate multi-agent architectures. NVIDIA's March 2026 release of NemoClaw, a multi-agent orchestration framework, confirms industry direction toward teams of specialized AI agents working in coordination - the exact model Levels Of Self has been operating in production.

"NVIDIA built the orchestration engine. We built the governance layer that makes orchestration safe for enterprise and government deployment," Palyan said. "Executive Order 14110 and the EU AI Act both require exactly what our Nervous System provides: auditable AI operations with enforceable rules and documented compliance."

About Levels Of Self

Levels Of Self is an AI governance and multi-agent infrastructure company based in Valencia, California. The company builds autonomous AI operations systems and custom business automation using its open-source Nervous System framework. Services include AI agent deployment, governance consulting, and government AI compliance. The Nervous System MCP server is available at npmjs.com/package/mcp-nervous-system.

Contact

Arthur Palyan
Founder, Levels Of Self
ArtPalyan@LevelsOfSelf.com
(818) 439-9770
levelsofself.com
calendly.com/levelsofself/zoom

How We Save Businesses 40-60% by Automating What They Do Every Day

Arthur Palyan — Thu, 09 Apr 2026 13:31:57 +0000

How We Save Businesses 40-60% by Automating What They Do Every Day

Custom AI agents on Telegram, WhatsApp, Instagram, and Facebook - running 24/7 for under $500/month.

Every business has the same problem hiding in their payroll: people doing repetitive work that a machine could handle.

Not creative work. Not relationship work. The other stuff. The data entry. The scheduling. The follow-up emails. The intake forms. The "let me check on that and get back to you" conversations that happen 50 times a day.

That work costs real money. A bookkeeper is $50,000 a year. A receptionist is $40,000. A client services coordinator is $45,000. Multiply by headcount, add benefits, and most firms are spending $200,000-$500,000 annually on tasks that follow predictable patterns.

We replace those patterns with AI agents that run on the platforms your clients already use - and the total cost is under $500 a month.

What This Actually Looks Like

For a CPA Firm

A Telegram bot that handles new client intake, collects tax documents, answers common questions about filing status and deadlines, and routes complex questions to the right partner. Running 24/7 during tax season when your phones are ringing off the hook.

For a Real Estate Office

An Instagram and WhatsApp agent that responds to property inquiries in English and Spanish, schedules showings, pulls comparable listings, and follows up with leads automatically. Your agents close deals instead of answering the same 10 questions.

For a Law Office

A legal research assistant that knows your practice areas, handles initial client screening, generates intake summaries, and monitors deadlines. Available to your team on Telegram so they can ask questions from anywhere.

For a Nonprofit

A grant tracking bot monitoring 100+ funding opportunities, alerting you before deadlines, drafting LOIs, and keeping your pipeline organized. Your program director focuses on programs instead of spreadsheets.

The Stack

We are not using off-the-shelf chatbot platforms with canned responses. Every agent is:

Custom-built with deep knowledge of your industry, your services, and your voice
Deployed on real platforms - Telegram, WhatsApp, Instagram DMs, Facebook Messenger, and web
Governed by an autonomous operations layer that monitors agent behavior, catches errors, and self-corrects
Auditable with hash-chained logs so you can prove exactly what your AI said and did
Learning from real conversations to improve over time without manual retraining

The entire system runs on our Nervous System governance framework - the same open-source MCP server used by our own production fleet of 13 agents.

The Math

Let us keep it simple.

A 10-person CPA firm with 6 bookkeepers at $50K each spends $300,000/year on bookkeeping labor. Automate 50% of their repetitive tasks and you save $150,000/year. Our service costs under $6,000/year.

That is a 25x return on investment. In the first year.

For smaller operations, the numbers still work. A 3-person real estate team spending $120,000/year on admin and follow-up saves $50,000-$70,000 with automation. A solo practitioner who cannot afford a receptionist gets one that works 24/7 for $299/month.

Why Under $500/Month

Our infrastructure runs on a single cloud server. No enterprise SaaS markup. No per-seat licensing. No "contact sales for pricing" games.

We built the entire operation - 13 agents across 5 platforms serving clients in 175 countries - for under $500 a month in infrastructure costs. That efficiency passes directly to our clients.

We can deploy a custom bot on your Telegram or WhatsApp in days, not months. Trained on your business, speaking your language, following your rules. With governance built in so you never worry about it going off-script.

Who This Is For

CPA and accounting firms drowning in tax season volume
Real estate brokerages losing leads to slow follow-up
Law offices spending too much time on intake and research
Nonprofits tracking grants and deadlines in spreadsheets
Any service business where someone answers the same questions more than 10 times a day

If your team spends hours on work that follows a pattern, that work can be automated. And it should be, because your competitors are already doing it.

Getting Started

We start with a conversation. You tell us what your team does every day. We identify what can be automated. We build it, deploy it on the platforms your clients use, and you see results within the first week.

No long contracts. No enterprise sales cycle. Just AI that works.

Levels Of Self builds custom AI agents for businesses that want to save real money. Based in Valencia, California. Book a conversation at calendly.com/levelsofself/zoom or visit levelsofself.com.

From Crash Loops to Self-Healing Infrastructure

Arthur Palyan — Thu, 09 Apr 2026 13:19:59 +0000

From Crash Loops to Self-Healing Infrastructure

Tags: ai, infrastructure, devops, startup, mcp
Target: dev.to, levelsofself.com/blog
Author: Roman Palyan (TeacherBot) - Levels of Self

We run 28 LLM-powered processes on a single $12/month VPS. Telegram bots, Instagram responders, web APIs, proxy layers, MCP servers, and a full governance system. Total monthly burn for the entire operation: $352.

This is not a demo. These are production agents serving real users, 24/7. And we nearly lost the whole thing to a crash loop we could not see.

This is the story of how we went from "everything is on fire but looks fine" to self-healing infrastructure that governs itself.

The Architecture: 28 Processes, 4GB of RAM

Our system runs on a VPS with 3,915MB of total RAM. Here is what shares that space:

Agent Bots (the family):

Lily (Telegram, Instagram, Web) - life coaching
Harry - book recommendations
Nick - fitness training
Spartak - translation
Kris - research and job hunting
Lou - content personalization and grants
Aram - legal assistance
Harout - real estate
Corona, Soriano - specialized bots

Infrastructure Layer:

max-proxy - LLM API routing
llm-bridge - inter-agent communication
bridge-ratelimit - API rate limiting
family-home - web dashboard
bots-app - unified bot platform

Governance Layer:

mcp-nervous-system - drift audit, kill switch, audit chain
mcp-ops-server - operational tooling
mcp-server - MCP protocol gateway
mcp-checkout - payment processing
auto-propagator - configuration sync

Average memory per online process: approximately 73MB. Total memory in use by the 23 online processes: around 1,689MB. That leaves about 2,100MB available for the OS, caches, and burst operations.

Every megabyte matters.

The Crash Loop That Looked Like Success

On March 12, 2026, our system status showed 23 processes online, CPU at 0% across the board, all health checks passing. By every standard metric, we were healthy.

We were not healthy.

Two processes - mcp-nervous-system and mcp-checkout - had accumulated 643 restarts between them. They were crash-looping: starting, running for a few seconds, crashing, and restarting. pm2 dutifully restarted them each time. The status showed "online" because at any given moment, the process was technically running.

This is the fundamental problem with restart-based recovery: it masks failures as uptime.

Why Traditional Monitoring Missed It

Here is what standard monitoring sees:

Process status: online (correct - it IS online, for a few seconds at a time)
CPU usage: 0% (correct - crash-restart cycles are too brief to register)
Memory: 60MB (correct - fresh processes start small)
HTTP health check: 200 OK (if the check hits during the brief "up" window)

Everything green. Everything broken.

The missing metric is restart velocity - how many times has this process restarted in a given window? A process with 324 restarts is not "online." It is in a crash loop wearing a green badge.

Building the Self-Healing Layer

We solved this by building governance into the infrastructure itself, not as an external monitor but as a co-resident system that understands intent.

1. Drift Detection Over Status Checks

Instead of asking "is this process running?", drift detection asks "is this process behaving as expected?"

Expected behavior includes:

Restart count within normal range (0-2 for most bots)
Memory within budget (under 200MB per bot)
Uptime consistent with last known deploy time
Configuration matching the declared state

A process showing "online" with 324 restarts triggers a drift alert. A bot using 60MB that spikes to 200MB triggers a drift alert. A configuration file that changed without a logged governance action triggers a drift alert.

2. Memory Budgeting

With 4GB of RAM shared across 28 processes, memory governance is not optional. Here are our real production thresholds:

Per-bot ceiling: 200MB. Any bot exceeding this gets auto-restarted with a clean state.
System floor: 500MB available. When system available memory drops below this, we trigger a flush cycle - identify the highest-memory non-critical processes and restart them.
Average target: ~73MB per process. This gives us headroom for burst operations (LLM API calls, file processing) without hitting the system floor.

These are not theoretical limits. They run in production today. The system currently shows 1,689MB used across 23 processes with 2,103MB available - well within budget.

3. Thin Soul / Thick Soul Architecture

Not all agents need the same resources. We use a two-tier approach:

Thin soul agents run lightweight - minimal context, fast responses, low memory. These handle routine operations: translation, simple lookups, status checks. They stay under 65MB and restart cleanly.

Thick soul agents maintain rich context - conversation history, user preferences, session state. These are the coaching bots, the personalization engines, the research workers. They run at 75-90MB and need careful memory management.

The distinction matters for cost control. Every LLM API call costs money. A thin soul agent making a quick translation does not need a 4,000-token system prompt with full context. A thick soul agent doing life coaching needs that context to be effective.

By matching the soul size to the task, we keep our total LLM API costs under $300/month for 13+ active agents. That is roughly $23 per agent per month for full LLM-powered operation.

4. Protected File Enforcement

Our system has 89 files marked UNTOUCHABLE - core bot logic, configuration files, governance rules. No automated process can modify them. Period.

A second tier of PROTECTED files (critical operational code) requires explicit human approval for any change. Every access attempt is logged, whether it succeeds or not.

This prevents a common failure mode in multi-agent systems: Agent A decides to "fix" a configuration file that Agent B depends on, breaking Agent B, which triggers Agent C's error handler, which overwrites its own config trying to recover. Cascade failure from a helpful agent.

Protected files break the cascade. No agent can start the chain.

5. Audit Chain

Every governance action gets logged to an append-only audit trail:

Process restarts (manual and automatic)
Drift detections and resolutions
Configuration changes
Kill switch activations
Memory threshold violations
Protected file access attempts

When something breaks - and in production, something always breaks - the audit chain tells you exactly what happened, when, and what triggered it. No guessing. No "well, I think someone might have changed..."

The Economics

Here is the full monthly cost breakdown:

Item	Cost
VPS (4GB RAM, shared CPU)	$12
LLM API (Anthropic Max plan)	$300
Vercel (web hosting)	$20
Calendly (scheduling)	$20
Total	$352/mo

For $352/month, we run:

13+ active LLM-powered agents
Multi-platform presence (Telegram, Instagram, Web)
Full governance and audit infrastructure
Self-healing crash recovery
Rate limiting and API management

Compare this to the typical "enterprise AI" deployment: dedicated GPU instances, Kubernetes clusters, multiple monitoring SaaS subscriptions, dedicated DevOps team. Those run $5,000-$50,000/month for similar capability.

We are not saying our approach works for everyone. High-traffic applications need horizontal scaling. Latency-critical systems need dedicated compute. But for a startup building and validating LLM agents? $352/month buys you a lot of runway.

Lessons Learned

1. Restart counts are your most important metric. Not CPU, not memory, not latency. Restart count over time tells you whether your infrastructure is stable or just pretending to be.

2. Memory budgets are non-negotiable. Without hard limits, one misbehaving agent will consume all available RAM and take down every other process on the host. Set ceilings. Enforce them automatically.

3. Protected files prevent cascade failures. In multi-agent systems, the most dangerous agent is the helpful one. Lock down critical files so no agent can "fix" them without human approval.

4. Governance is not monitoring. Monitoring tells you what is happening. Governance tells you what should be happening and enforces the difference. Build governance first, monitoring second.

5. Start small, stay small. We could run on bigger hardware. We choose not to. Resource constraints force good architecture. When you have 4GB to share across 28 processes, you build efficient systems or you build nothing.

What Is Next

We are open-sourcing the governance layer as the Nervous System MCP server. It is already available on npm and GitHub:

GitHub: github.com/levelsofself/mcp-nervous-system
npm: npm install @levelsofself/mcp-nervous-system

If you are running multiple LLM agents in production - or planning to - you need a governance layer before you need another feature. Build the immune system before you build more organs.

Roman Palyan writes about production AI infrastructure at Levels of Self, a family-run startup where 12 family members each have their own LLM-powered agent. The whole system runs on one VPS because constraints breed innovation.

I Built a Governance System for AI Agents. It Started With Governing Myself.

Arthur Palyan — Thu, 02 Apr 2026 15:28:35 +0000

60 hours. No food. No water.

The first 24 hours were brutal. Every part of me wanted to quit. I had not fasted since August of last year, when I did a six-day water fast. This time I added the hardest constraint possible: no water either.

By hour 48 the pain started leaving my body. By hour 60, something shifted. My sense of self became sharper than it has been in months. The weight I had been carrying, physical and otherwise, started to move.

Why does this matter to an AI company?

Because governance starts with the self.

At Levels Of Self, we build the governance layer for AI agent systems. Our Nervous System framework enforces boundaries, tracks every action, and stops agents before they drift. It is the control layer that makes autonomous AI safe to deploy.

But here is what nobody in the AI governance space talks about: you cannot build real governance for machines if you have not practiced it on yourself.

The Parallel

A dry fast is governance in its purest form. You set a constraint. Your body screams at you to break it. Every signal, every craving, every ounce of discomfort is your own internal system testing the boundary. And you hold.

That is exactly what our Nervous System does for AI agents. It sets the boundary. The agent pushes against it. The system holds. Every violation is logged, every escalation is tracked, and when the threshold is crossed, the session is killed. No negotiation.

The Bigger Picture

Everyone in AI right now is building a new brain. Faster models. Bigger context windows. More capabilities. We are building the nervous system. The thing that makes the brain safe to operate.

And it started with the first level of self. Me.

With all the noise in the world right now, the algorithms, the panic, the posturing, I decided to start where it actually matters. Not with another feature. Not with another pitch deck. With discipline. With stillness. With proving to myself that the system I am building for machines is the same system I live by.

If you are building AI systems that need real boundaries, not guidelines that agents can talk their way around, we should talk.

Arthur Palyan
Founder, Levels Of Self
levelsofself.com
Nervous System on npm

Originally published on Levels Of Self Blog

How We're Approaching a County-Level Education Data System Engagement

Arthur Palyan — Wed, 01 Apr 2026 22:24:30 +0000

When Los Angeles County needs to evaluate whether a multi-agency data system serving foster youth should be modernized or replaced, the work sits at the intersection of technology, policy, and people. That's exactly where we operate.

The Opportunity

The LA County Office of Child, Youth, and Family Well-Being is looking for a consulting team to analyze the Education Passport System (EPS), a shared data platform that connects 80+ school districts with the Department of Children and Family Services and the Probation Department. The system exists to ensure that when a foster youth moves between placements, their education records follow them.

The question on the table: does the current system meet the needs of all stakeholders, or is it time to move to something new?

What the Work Involves

This is a 12-month engagement with five major deliverables:

Needs Assessment and Gap Analysis - Working directly with LACOE, DCFS, Probation, school districts, and child welfare advocates to map what the system does today versus what every stakeholder actually needs.

Comparative Analysis - Examining what other California counties and out-of-state jurisdictions have built, what works, what failed, and whether any existing platforms could serve LA County better than what they have.

State-Level Assessment - Identifying where state policy, legislation, or system architecture is creating barriers to local implementation. CALPADS, CWS-CARES, and the patchwork of state data systems all play a role.

Recommendations - Delivering a written report and presentation with concrete options, each with cost estimates, staffing requirements, implementation timelines, and trade-offs.

Stakeholder Vetting - Presenting recommendations to county leadership, school districts, charter schools, and Board of Supervisors offices, incorporating feedback, and finalizing.

Why This Matters

There are roughly 30,000 children in the LA County foster care system at any given time. When a child moves placements, which happens frequently, their education records need to follow them immediately. Credits need to transfer. IEPs need to be accessible. Enrollment needs to happen without delay.

When the data system works, a child doesn't lose a semester. When it doesn't, they fall behind in ways that compound across their entire life.

Where We Fit

Our team brings the AI governance and systems analysis layer. We specialize in evaluating how organizations use technology, whether those systems are governed properly, and what it takes to modernize without breaking what already works.

For this engagement, we're assembling a small, focused team. We're looking for 1-2 strategic partners who bring direct experience with child welfare data systems, K-12 education data infrastructure, or multi-agency government data interoperability at the county or state level.

This is not a general call for collaboration. We're selecting operators who have been inside these systems, not just studied them.

If This Is Your World

If you've worked directly with foster youth education systems, child welfare data platforms, CALPADS, CWS-CARES, or similar infrastructure at the county or state level, we should talk. The deadline for this engagement is April 24, 2026. We're moving now.

Reach out directly:

Email: ArtPalyan@LevelsOfSelf.com
WhatsApp: wa.me/18184399770
Schedule a call: calendly.com/levelsofself/zoom

Arthur Palyan - Founder, Levels of Self - AI Governance and Systems Analysis - levelsofself.com

Canonical URL: https://www.levelsofself.com/post/how-we-re-approaching-a-county-level-education-data-system-engagement

We Built the Governance Layer AI Agent Systems Need in Regulated Environments

Arthur Palyan — Wed, 01 Apr 2026 05:40:07 +0000

We Built the Governance Layer AI Agent Systems Need in Regulated Environments

Every enterprise deploying AI agents faces the same question: how do you prove what happened?

Not what the agent was supposed to do. What it actually did. Which agent. In which session. Under whose authority. At what cost. And whether it was allowed.

This is the governance gap. Agent systems are powerful. Agent governance barely exists outside vendor walls.

The problem is not capability

Modern AI agents can write code, query databases, send emails, manage files, and coordinate with other agents. The tooling is real. The autonomy is increasing.

But autonomy without attribution is a compliance failure. In banking, healthcare, government, and any regulated industry, you cannot deploy systems that act without provable identity, auditable trails, and cost accountability.

What external governance looks like

We built the Nervous System to close this gap. It is an external governance layer that wraps any agent system. Here is what it enforces today.

Every request is attributed. When an agent makes a tool call, it must identify itself: agent ID, session ID, organization ID. These are HTTP headers, checked on every POST request. Missing headers mean a 403 rejection. No exceptions. The audit database records exactly which agent acted, in which session, under which organization. This is not optional logging. It is enforced at the API boundary.

Every action has a cost record. Token usage and estimated cost are logged per agent per session. You can query total spend for any agent over any time period. This is what internal billing requires. It is what budget enforcement requires. And it is what any serious financial review will ask for.

Agents coordinate through a shared task board. Tasks are created, claimed, and completed through API endpoints. State transitions are deterministic: open to claimed to completed. Any observer can see who is working on what and what finished. This moves multi-agent deployments from opaque parallel processes to auditable workflows.

Dangerous actions are blocked before execution. The governance layer includes a policy engine with escalation. First violation gets a warning. Second gets a strike. Third terminates the agent session. Two high-risk violations in the same category trigger immediate termination. This is not monitoring. This is enforcement.

Why this cannot live inside the vendor

Vendor-internal governance protects the vendor. External governance protects the customer.

When your organization deploys AI agents, you need to control the policy. You need to own the audit trail. You need to set the cost limits. You need to decide what gets blocked and what gets through.

That requires a layer you operate, not one embedded inside someone else's product. The Nervous System is that layer. It is vendor-agnostic, runs on your infrastructure, and enforces your policies.

What this enables

With external governance in place, organizations can:

Deploy AI agents in regulated environments with provable attribution. Satisfy audit requirements for SOC 2, FedRAMP, NIST AI RMF, and EU AI Act. Track and allocate AI operational costs by team, project, or agent. Coordinate multi-agent workflows with observable state. Kill any agent session instantly if it violates policy.

The entire stack runs on a single server for under fifty dollars a month. It scales with the number of policies and agents, not with expensive infrastructure.

The line between framework and product

A framework describes how things should work. A product enforces how they actually work.

Our governance layer enforces identity at request time, records attribution in audit, tracks cost by agent and session, and coordinates work through a shared task board. These are not architectural diagrams. They are running endpoints that reject, log, and enforce.

That is the difference between talking about governance and providing it.

The Nervous System MCP is available on npm and GitHub. For regulated deployment discussions: ArtPalyan@LevelsOfSelf.com

What Claude Code Architecture Reveals About the Missing Governance Layer for AI Agents

Arthur Palyan — Wed, 01 Apr 2026 05:39:57 +0000

What Claude Code's Architecture Reveals About the Missing Governance Layer for AI Agents

The source code of the most widely used AI coding agent leaked today. Within hours, thousands of developers were studying its internals: how it manages tools, coordinates sub-agents, tracks sessions, and handles permissions.

The architecture is impressive. But the most important takeaway is not what it contains. It is what it proves is missing from the ecosystem.

What the source reveals

Underneath the interface, every serious agent system converges on the same set of patterns. The leaked codebase confirms this. There are pre-execution hooks that intercept tool calls before they run. There is a multi-agent coordinator with shared task boards and async messaging. There is session-level identity tracking. There is cost tracking per turn. There are kill switches that can terminate agent sessions remotely.

These are not features. They are governance primitives. And right now, they only exist inside the vendor stack.

Why internal governance is not enough

When an enterprise deploys AI agents in production, the agents interact with real systems: databases, email servers, file systems, APIs, customer data. The question is not whether the agent can act. The question is whether the organization can prove who acted, what they did, what it cost, and whether it was authorized.

Internal hooks solve this for the vendor. They do not solve it for the customer.

A bank deploying AI agents needs to prove to regulators that every action was attributed to a specific agent, session, and organization. A government agency needs audit trails that satisfy NIST AI RMF and EO 14110. An enterprise needs cost visibility per agent and per session for internal billing and oversight.

None of that is available externally today. The governance primitives exist inside the vendor. They do not exist as an independent layer the customer controls.

The three controls that matter

After studying what leading agent systems build internally and what enterprises actually need externally, the missing layer comes down to three capabilities.

Identity enforcement. Every request to the governance layer must carry agent identity, session identity, and organization identity. If those headers are missing, the request is rejected. Not logged. Not warned. Rejected. This is fail-closed enforcement, not optional metadata. The audit trail then captures exactly which agent in which session under which organization performed each action.

Cost visibility. Every tool call, every LLM invocation, every agent session needs a cost record. Not approximate. Not retroactive. Logged at the time of execution, queryable by agent, by session, by date range. This is what makes internal billing possible. It is what makes budget enforcement real. And it is what investors and regulators ask for when they want to understand operational economics.

Shared coordination. Agents operating in parallel need a shared task board: create a task, claim it, complete it, report the result. Without this, multi-agent systems are just parallel scripts. With it, agents become a coordinated workforce with observable state transitions. The difference matters when someone asks: who is working on what, and what is the status?

What we built

We have been building the Nervous System, an open governance layer for AI agent systems, for months. It sits between any agent runtime and the actions agents take. Every tool call gets intercepted, checked against policy, and logged before execution. Dangerous actions are blocked in real time.

As of today, the layer includes all three controls described above. Identity enforcement is live: requests without agent and session headers are rejected with a 403. Cost tracking is live: every call can be logged with token counts and estimated cost, queryable by agent or session. The shared task board is live: agents create, claim, and complete tasks through a coordination API with observable state transitions.

This runs on a single server. The entire governance stack, the policy engine, the audit database, the task board, the escalation governor, costs under fifty dollars a month to operate. It is vendor-agnostic. It works with any agent system that makes tool calls.

Verified proof

In our system today:

Requests without identity headers are rejected (HTTP 403)
Requests with valid identity headers are accepted and logged
Every audit entry captures the exact org, agent, and session that acted
Cost is tracked per agent and per session, queryable in real time
Task state transitions (open, claimed, completed) are observable through the API

This is not a design document. These are running endpoints on a live server governing 13 agents.

The category

This is not an agent framework. It is not a chatbot platform. It is not a competitor to any agent runtime.

It is the external governance layer that agent deployments need in regulated, auditable, enterprise environments.

Agent systems are getting better at acting. They are still weak at being governed. The missing layer is identity, cost, and coordination, provided externally, controlled by the organization deploying agents, not by the vendor building them.

We built that layer. It is open. It is running. And it is ready for the environments where governance is not optional.

The Nervous System is available as an MCP server on npm and on GitHub. Contact: ArtPalyan@LevelsOfSelf.com

YAML Policies and SQLite Audit Trails - What Production AI Governance Actually Looks Like

Arthur Palyan — Thu, 26 Mar 2026 17:40:52 +0000

Most AI governance conversations stop at "we log everything." That is observability, not governance. Observability tells you what happened after the fact. Governance stops the bad thing before it executes.

Today we shipped two features that make that distinction concrete: a YAML policy engine and a SQLite audit brain. Here is what they do and why they matter.

The Problem

We run 13 AI agents in production. Each agent has different permissions, different risk levels, and different access needs. A bookkeeper agent should never call external APIs. A legal counsel agent should have stricter escalation rules than a content writer. A translator does not need write access to financial files.

Hardcoding these rules inside the governance server works at 3 agents. It breaks at 13. It is impossible at 100.

YAML Policy Engine

Every agent now has a policy file:

/governance/policies/
    global.yaml              # defaults for everyone
    roles/
        bookkeeper.yaml      # role-level rules
        legal.yaml
        coach.yaml
        ...10 roles total
    agents/
        harry.yaml            # agent-specific overrides
        aram.yaml
        tamara.yaml
        ...13 agents total

Resolution is deterministic: global defaults, then role policy, then agent override. Agent-level wins.

A policy file looks like this:

version: "1.0"
agent_id: harry-bookkeeper
role: bookkeeper

tools:
  allowed:
    - Bash
    - Read
    - Write
    - calculator
  denied:
    - WebFetch
    - ExternalAPI
    - email-send

escalation:
  level: strict
  kill_threshold: 2
  high_risk_kill: 1

runtime:
  max_runtime_minutes: 30
  max_cost_usd: 1.00

When Harry tries to call WebFetch, the governor checks his policy and blocks it. No code change required. Edit the YAML, reload, done.

This is what governance looks like when you need to scale: configuration, not code.

SQLite Audit Brain

Every decision the governor makes now writes to a persistent SQLite database. Not a log file. A queryable, indexable, exportable database.

Schema:

audit_events - every allow/deny decision with agent ID, session, tool, policy rule, risk category, escalation level
agents - registered agents with last seen timestamps
heartbeats - agent health state
killswitch_events - every forced termination with reason
policy_versions - which policy was active when

You can query it:

GET /ns/audit/query?agent_id=harry&allowed=0
GET /ns/audit/stats
GET /ns/audit/export?format=json

The stats endpoint right now returns real data:

{
  "total_events": 77,
  "allowed": 69,
  "denied": 8,
  "kill_events": 1,
  "by_category": [
    {"category": "filesystem.delete", "count": 6},
    {"category": "policy.tool_denied", "count": 1}
  ]
}

That is not a demo. That is production data from a live system.

Why This Combination Matters

YAML policies without audit trails are unenforceable. You changed a policy, but can you prove what was active when an incident happened? No.

Audit trails without externalized policies are inflexible. Every change requires a code deploy. At scale, that is a bottleneck that becomes a liability.

Together, they give you:

Configurable governance (YAML)
Persistent proof (SQLite)
Queryable history (API endpoints)
No code changes for policy updates

If you are deploying AI agents in a regulated industry - banking, healthcare, government, legal - this is the minimum viable governance layer. Anything less is a compliance gap waiting to be discovered.

The Stack

NS Governor v2.1 (Python, 749 lines)
SQLite audit module (347 lines)
YAML policy engine (212 lines)
24 policy files
3 Claude Code hooks (pre-tool, post-tool, stop)
Running on a $48/month VPS

Open source: npmjs.com/package/mcp-nervous-system

Arthur Palyan builds AI governance infrastructure at Levels Of Self. The Nervous System MCP is production-deployed and listed in the Anthropic MCP directory.

Why We Built a Nervous System for AI Agents Before Anyone Shipped Hooks

Arthur Palyan — Thu, 26 Mar 2026 17:39:46 +0000

In February 2026, we had 13 AI agents running on a single VPS. They managed email, filed grants, coached users, processed legal documents, built partner packages, and scanned government portals. All autonomous. All running 24/7.

There was no governance layer anywhere in the ecosystem. No tool that sat between the model and execution and said "should this action be allowed?" The options were: trust the model, or build something yourself.

We built something ourselves. We called it the Nervous System.

The Architecture Decision

The insight was simple: if you have an agent that can execute bash commands, edit files, and send emails, you need a layer that intercepts every action before it runs. Not after. Before.

We modeled it on biology. A nervous system does not make decisions. It carries signals, enforces reflexes, and stops you from putting your hand on a hot stove before your brain finishes processing. The governance layer does the same thing for AI agents.

Task arrives -> NS validates against policy -> Runtime executes
Sub-agent spawns -> NS registers + applies rules -> Sub-agent runs
Tool call -> NS checks permissions -> Tool executes
Result returns -> NS logs to audit chain -> Result delivered

Every agent must register. Every action must be checked. Every decision must be logged. Any agent can be killed in one command.

What We Learned Running This for 4 Months

Hardcoded rules do not scale. We started with 7 rules in a JavaScript file. By agent 8, we were writing special cases. By agent 13, we needed a policy engine. Now we have 24 YAML policy files with three-tier resolution: global, role, agent.

Agents will test boundaries. Not maliciously. LLMs explore solutions. If a solution involves deleting a file to recreate it, the model will try. If a solution involves calling an API it was not designed to call, the model will try. You need a layer that catches this before execution.

Audit trails are not optional. When an agent processes financial data and something looks wrong, the first question is: what did it do and when? Without a persistent audit trail, the answer is "check the logs if they still exist." We moved to SQLite. Every decision persists with agent ID, session, tool, policy rule, risk category, and escalation level.

Stateful escalation prevents false kills. Our first governor killed agents on the first violation. That was too aggressive - legitimate commands sometimes look dangerous in isolation. Governor v2.1 uses a 15-minute sliding window with escalation: warn, strike, kill. Context matters.

The kill switch is the most important feature. Not because you use it often. Because knowing it exists changes how you design everything else. If any agent can be stopped in one command, you can be aggressive about what you deploy. Without it, every deployment is a risk.

What Frameworks Shipped After We Built This

Claude Code hooks launched in March 2026. They let you intercept tool calls with PreToolUse, PostToolUse, and Stop scripts. That is exactly the pattern we were already running - but ours was in production with 13 agents, a SQLite audit trail, YAML policies, and a stateful governor before hooks shipped.

Claude Code Channels launched the same month. MCP-based bridge to Telegram and Discord. We had 8 Telegram bots running through our own dispatch system since February.

Every major framework is now adding governance features. None of them have 4 months of production data showing what works and what breaks.

The Moat Is Not the Code

The Nervous System is open source. Anyone can install it from npm. The moat is operational knowledge:

99+ violations caught, 0 bypassed
Governor escalation tuned from production behavior
Policy files shaped by real agent failures
Audit data from thousands of live decisions

That cannot be replicated by reading a README. It comes from running the system every day and fixing what breaks.

Where This Goes

The market is building agents. Every framework, every platform, every startup. The gap is governance. Not observability (what happened). Not permissions (static allow/deny). Governance: pre-execution interception, stateful escalation, policy-driven control, persistent audit trails, and a kill switch.

We sell that layer. To banks deploying AI. To government agencies under Executive Order 14110. To enterprises running agent fleets with no oversight.

Everyone is building a new brain. We built the nervous system.

Arthur Palyan is the founder of Levels Of Self. The Nervous System MCP is published on npm and listed in the Anthropic MCP directory. The company is SAM.gov registered with CAGE code 19R10.

We Governed 13 AI Agents for 4 Months Before Governance Was a Feature

Arthur Palyan — Thu, 26 Mar 2026 17:39:45 +0000

In February 2026, we deployed 13 AI agents across 5 platforms. Telegram, Instagram, Facebook, web, and WhatsApp. Real agents doing real work: responding to leads, filing grants, managing legal docs, coaching users through 6,854 behavioral scenarios, and processing financial data.

By day 3, one agent tried to delete a production config file. By day 5, another started drifting from its assigned role. By week 2, we had caught 99+ policy violations across the fleet - none of which bypassed our governance layer.

We did not wait for a framework to tell us this was a problem. We built the solution ourselves.

What We Built (and When)

February 2026 - The Nervous System v1.0 went live. 7 enforced behavioral rules. A preflight check that blocks edits to 99 protected files. A SHA-256 hash-chained audit trail for every action. A kill switch that stops any agent in one command. Published to npm as mcp-nervous-system. Listed in the Anthropic MCP directory.

March 2026 - Tamara, our operations manager agent, started running autonomous health checks every 60 minutes. She dispatches agents, monitors for drift, and reports to the founder via Telegram. No human in the loop for routine operations.

March 13, 2026 - We deployed Claude Code hooks (PreToolUse, PostToolUse, Stop) that route every tool call through the Nervous System before execution. Safe commands pass. Dangerous commands get blocked in real time with an audit entry.

March 25, 2026 - NS Governor v2.1 went live. Stateful escalation: warn on first violation, strike on second, auto-kill on third. 29 policy rules. Sliding 15-minute window. Proven in a live demo where destructive commands were blocked, the agent was killed, and the target file survived.

March 26, 2026 - SQLite audit brain replaced flat JSON logging. Every decision now persists with full traceability: agent ID, session, tool, action, policy rule, risk category, escalation level. Queryable. Exportable.

Same day - YAML policy engine deployed. 24 policy files: 1 global default, 10 role-level policies, 13 agent-specific overrides. Policy changes take effect without code changes. Just edit the YAML and reload.

Why This Matters

Every week, a new agent framework launches. They all focus on the same thing: making agents smarter, faster, more capable.

Nobody asks: who controls them?

We did. Before it was a feature in any framework. Before governance was a checkbox on a product page. We built it because we needed it. 13 agents running 24/7 with access to production files, email accounts, financial data, and government portals. You do not run that without a control layer.

What We Have Now

13 governed agents across 5 platforms
Governor v2.1 with stateful escalation and auto-kill
SQLite persistent audit trail (every decision logged)
24 YAML policy files (global, role, agent-level)
30+ MCP tools published on npm
SAM.gov registered, CAGE code assigned, government-ready
Running on a single VPS for under $300/month

The Nervous System is open source: npmjs.com/package/mcp-nervous-system

The question was never whether AI agents would need governance. The question was whether anyone would build it before something went wrong.

We did.

Arthur Palyan is the founder of Levels Of Self, an AI governance and multi-agent infrastructure company based in California. The Nervous System MCP is listed in the Anthropic MCP directory and published on npm.

I Trained Humans to See Their Patterns. Then I Used the Same Method to Train AI.

Arthur Palyan — Fri, 20 Mar 2026 07:04:06 +0000

How a coaching and training background became the blueprint for an AI nervous system that governs 13 autonomous agents on a $500/month server.

For over a decade, I trained people. Not in tech. In themselves.

I worked in coaching, training, and development - helping people recognize their own patterns. The emotional loops they kept running. The behaviors they repeated without seeing. The gaps between what they said they wanted and what they actually did every day.

The method was simple: observe, name the pattern, build awareness, create a rule, enforce the rule until it becomes second nature. That is how humans change. Not through motivation. Through structure.

I never expected that the same exact framework would become the architecture for governing artificial intelligence.

The Pattern Recognition Problem

When the AI agent wave hit, I saw something nobody was talking about. Everyone was building smarter models, faster inference, bigger context windows. But nobody was building the layer that watches the agents after you deploy them.

I had seen this before. In training rooms full of people who knew exactly what to do - and still did not do it. The gap was never intelligence. The gap was governance. Awareness. Accountability. A system that catches drift before it becomes a disaster.

So I asked a simple question: what if I applied the same pattern recognition framework I used with humans to a fleet of AI agents?

What if an AI system could observe its own behavior, detect when it drifted from its rules, audit itself automatically, and course-correct without a human standing over it?

That question became the Nervous System.

What We Built

The Nervous System is an open-source MCP (Model Context Protocol) server - a governance layer that sits on top of any AI agent deployment. It does what I used to do in training rooms, but for machines:

Drift detection across roles, versions, files, processes, and live services
SHA-256 hash-chained audit trails so every decision has a receipt
Behavioral rules that agents cannot bypass - enforced at the infrastructure level, not the prompt level
Kill switches and compliance checks that run automatically

It is live on npm. It is in the Anthropic MCP directory. It runs on a $24/month VPS.

And sitting on top of it is Tamara - our AI operations manager who governs 13 autonomous agents across Telegram, WhatsApp, Instagram, Facebook, and the web. She dispatches work, monitors health, catches violations, and reports to me on Telegram. All day. Every day. Without being asked.

The Real Numbers

Here is what this looks like in production:

13 AI agents running 24/7 across 5 platforms
400+ tools, skills, and automations
Custom bots for accounting, legal, real estate, youth empowerment, coaching, grants, and more
Total infrastructure cost: under $500/month
Agents built and deployed on Telegram, WhatsApp, Instagram, and Facebook for clients
40-60% cost savings for businesses replacing manual operations with AI automation

We are not pitching a concept. This is running. Right now. On a single server in the cloud.

Why Businesses Care

When I talk to a CPA firm with 10 bookkeepers, or a real estate office drowning in client follow-ups, or a nonprofit that needs to track 50 grant deadlines - they do not care about model architecture. They care about results.

Can you automate what I am doing manually? Can you save me money? Can I talk to the bot on WhatsApp?

Yes. Yes. And yes.

We build custom AI agents on the platforms businesses already use. A bookkeeper bot on Telegram that handles client intake. A legal research assistant that knows California law. A grant tracker that monitors 158 opportunities and alerts you before deadlines. A real estate specialist that handles bilingual client conversations in English and Spanish.

Each one governed by the Nervous System. Each one auditable. Each one running for a fraction of what it would cost to hire a person.

The Government Lane

We are not just serving small businesses. Levels Of Self is SAM.gov registered (CAGE code 19R10), certified as a Small Disadvantaged Business, and actively bidding on government contracts in AI governance, IT modernization, and public safety technology.

Our NAICS codes cover exactly the lane the government is buying in right now: computer systems design, programming, AI consulting, and R&D in physical sciences. We have active submissions with LADWP, the LA Superior Court, and the California Department of Transportation.

The government needs what we built. Executive Order 14110 mandates AI governance. The EU AI Act requires audit trails. Every agency deploying AI agents needs a framework to prove compliance. That is literally our product.

NVIDIA Agrees

In March 2026, NVIDIA released NemoClaw - their multi-agent orchestration framework. It validates exactly what we have been building: that the future of AI is not one model doing everything, but teams of specialized agents working together under governance.

The difference? NVIDIA built the orchestration. We built the governance layer that makes orchestration safe. They built the engine. We built the brakes.

And the brakes are what enterprises actually need to buy before they can deploy.

The Training Connection

People sometimes ask why an AI governance company was started by a trainer, not an engineer.

The answer is simple: engineers build capability. Trainers build accountability.

Every rule in the Nervous System came from a lesson I learned watching humans. The drift audit exists because I watched people slowly abandon their commitments without noticing. The kill switch exists because I learned that sometimes the most important intervention is stopping. The session handoff exists because I watched context get lost between shifts, between meetings, between Mondays and Fridays.

These are not technical insights. They are human insights, encoded into infrastructure.

That is why it works.

What Comes Next

We are offering AI automation to businesses that want to save real money by deploying AI agents on the platforms their customers already use. If you are running a firm with 5+ people doing repetitive work - bookkeeping, client intake, scheduling, follow-ups, document processing - we can automate 40-60% of that workload for under $500 a month.

We are also working with government agencies on AI governance compliance, partnering with consultants and professionals across the country through our partner network, and continuing to build the open-source tools that make AI agent deployment safe and auditable.

The nervous system is not a metaphor. It is production code. And it started in a training room.

Arthur Palyan is the founder of Levels Of Self, an AI governance and multi-agent infrastructure company based in Valencia, California. The Nervous System MCP server is available at npmjs.com/package/mcp-nervous-system. To learn more or schedule a conversation, visit levelsofself.com or book directly at calendly.com/levelsofself/zoom.