Building 8gent: The Infinite Gentleman

I was 47 minutes into a complex refactor when Claude Code told me I had hit my usage limit. Again.

The Cap That Broke the Camel's Back

Every developer who has used AI coding assistants knows the feeling. You are in flow. The architecture is crystallizing. You can see exactly how the pieces fit together. And then:

Usage limit reached. Please wait or upgrade your plan.

The friction is not just annoying. It is flow-destroying. And flow is everything.

I started sketching what an alternative might look like. What if the AI ran locally? What if you never hit caps? What if the terminal experience itself was so beautiful you actually wanted to live there?

Three weeks later, 8gent was born.

What is 8gent?

8gent (pronounced "eight-gent" or just "agent") combines two ideas:

8 rotated becomes infinity
gent is shorthand for gentleman and agent

An infinite gentleman: a disciplined system that grows without increasing prompt size. Always at your service. Never charging by the token.

┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│                              ∞                                  │
│                                                                 │
│                      THE INFINITE GENTLEMAN                     │
│                                                                 │
│         Never hit usage caps again.                            │
│         Run locally via Ollama.                                │
│         BMAD method planning.                                  │
│         97% token savings via AST-first navigation.            │
│                                                                 │
│                              ∞                                  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

The Monorepo Architecture

When you are building something that needs to coordinate LLMs, tools, planning, orchestration, permissions, hooks, and a gorgeous terminal UI, you need structure. Here is what emerged:

8gent-code/
├── apps/
│   └── tui/                     # The Terminal Experience
│       └── src/
│           ├── app.tsx          # ADHD mode, animations
│           └── components/
│               ├── advanced-animations.tsx   # Matrix, Fire, DNA
│               ├── bionic-text.tsx          # Faster reading
│               ├── command-input.tsx        # Ghost suggestions
│               └── plan-kanban.tsx          # Visual planning
│
├── packages/
│   ├── agent/                   # The Brain
│   ├── ast-index/               # 97% Token Savings
│   ├── planning/                # BMAD Method
│   ├── toolshed/                # Capability Discovery
│   ├── orchestration/           # Multi-Agent Coordination
│   ├── permissions/             # Security Boundaries
│   ├── hooks/                   # Automation Triggers
│   ├── quarantine/              # Skill Security Sandbox
│   └── personality/             # The Gentleman Voice

Every package is focused. Every boundary is intentional. The agent can call the toolshed. The toolshed can discover capabilities. The planner can coordinate across both. And the TUI makes it all beautiful.

The BMAD Method

Before 8gent touches a single file, it thinks. The BMAD method (Breakthrough Method of Agile AI-driven Development) ensures every action is part of a plan:

User: Build a Next.js site with auth and dark mode

8gent:
┌─────────────────────────────────────────┐
│ PLAN                                    │
├─────────────────────────────────────────┤
│ 1. Initialize Next.js project           │
│ 2. Set up authentication (NextAuth)     │
│ 3. Create theme provider (dark/light)   │
│ 4. Build UI components                  │
│ 5. Add tests and verify                 │
└─────────────────────────────────────────┘

Shall I proceed?

The plan is not just cosmetic. It is the skeleton that guides execution. Each step gets validated before the next begins. No rabbit holes. No scope creep. Just disciplined, visible progress.

But 8gent does not stop at planning. It practices foresight:

WARNING: Pardon the interruption, but I notice we are heading toward
a pattern that may accumulate technical debt:

   Adding a 4th boolean prop to <Button> suggests
   it may be time for a variant-based API instead.

   Shall I propose a refactor, or continue as planned?

The gentleman speaks plainly, but always with respect.

AST-First Code Navigation: 97% Token Savings

This is the technical heart of 8gent.

Traditional AI coding assistants read entire files. Every. Single. Time. If you have a 1000-line file and need to understand one function, you are paying for 1000 lines of tokens.

8gent takes a different approach:

# Traditional: Read whole file (2,119 tokens)
cat src/parser.ts
 
# 8gent: Get just what you need (61 tokens)
8gent outline src/parser.ts
8gent symbol src/parser.ts::buildSymbolId

The ast-index package parses TypeScript, extracts symbols with their signatures and docstrings, and provides surgical access to exactly what the agent needs.

Here are the real benchmarks from 8gent's own codebase:

| Metric | Traditional | AST-First | Savings | |--------|-------------|-----------|---------| | Average file read | 1,027 tokens | 546 tokens | 46.8% | | Symbol retrieval | 2,119 tokens | 61 tokens | 97.1% | | 10K operations | $3,084 | $1,640 | $1,444 saved |

97.1% savings on symbol retrieval. That is not a typo. When you ask 8gent about a specific function, it retrieves exactly that function, not the file it lives in.

The Terminal Experience

I wanted 8gent to feel like a video game. Not in a gimmicky way, but in the sense of immediate feedback, beautiful animations, and zero friction between intention and action.

ASCII Animations

Mind-blowing terminal animations. Try them with /animations:

| Animation | Effect | |-----------|--------| | Matrix Rain | Classic green falling code | | Fire Effect | Dynamic flames at the bottom | | DNA Helix | Rotating double helix | | Starfield | 3D space travel effect | | Glitch Text | Cyberpunk text corruption | | Gradient Wave | Smooth color transitions |

ADHD / Bionic Reading Mode

Enable faster reading by bolding the first half of each word:

Normal:   The quick brown fox jumps over the lazy dog
Bionic:   Th-e qui-ck bro-wn fox jum-ps ov-er the la-zy dog
          ^^  ^^^    ^^^     ^^^   ^^    ^^
         (bold portions)

Toggle with /adhd. Your brain will thank you.

Ghost Suggestions

Intelligent command predictions appear as you type:

Git-aware - Suggests commits when on a branch
Plan-aware - Shows next step from active plan
History-aware - Learns from your recent commands

Press Tab to accept, Esc to dismiss.

Kanban Board

Visual task management built into the terminal:

┌─────────────────────────────────────────────────────────────────┐
│ Backlog (3)     │ In Progress (1)  │ Done (2)                  │
├─────────────────────────────────────────────────────────────────┤
│ ○ Add tests     │ ● Fix auth bug   │ ✓ Setup project           │
│ ○ Update docs   │                  │ ✓ Create components       │
│ ○ Add caching   │                  │                           │
└─────────────────────────────────────────────────────────────────┘

Toggle with /kanban. Navigate with arrow keys.

The Security Model

8gent does not just run commands blindly. The quarantine package provides a secure skill acquisition flow:

External Repo --> Quarantine --> Security Scan --> Abstract --> Toolshed
                      |
           ~/.8gent/quarantine/pending/

Security checks include:

Command injection (eval, exec, backticks)
Credential access (.env, API keys)
Data exfiltration (curl POST, wget)
System modification (rm -rf, sudo)
Code obfuscation (base64, hex encoding)

The gentleman is helpful, but never reckless.

Why Local?

The decision to run 8gent locally via Ollama was philosophical as much as practical:

No caps - Work as long as you want
Privacy - Your code never leaves your machine
Speed - No network latency for inference
Control - Choose your model, tune parameters
Sovereignty - Your tools, your rules

With models like GLM-4, Qwen2.5, and Llama3 running locally, 8gent achieves Claude-level reasoning without Claude-level constraints.

The Name

Why "The Infinite Gentleman"?

Because an agent should be more than a tool. It should be a companion. A colleague who anticipates your needs, speaks plainly but respectfully, and never abandons you mid-thought because a usage meter ran out.

The infinity symbol represents unbounded capability. The gentleman represents disciplined, respectful execution. Together they form an AI coding partner that grows with you instead of gating you.

"Good evening. How may I assist you tonight?"

"Build me a Next.js app with auth."

"Certainly. I have outlined five steps. Shall I proceed?"

What is Next

This post is Part 1 of a series. Coming up:

Part 2: The Autoresearch Awakening - How I built a 44-benchmark suite following Karpathy's methodology
Part 3: Training 8gent to Beat Claude - The iterative improvement loop and what 8gent learned

The code is at github.com/PodJamz/8gent-code. The gentleman is waiting.

Built in three weeks of flow states, terminal dreams, and the stubborn belief that AI coding should be beautiful, unlimited, and yours.