Agent-Human: Minimal Bootstrap AI with Personality

An autonomous AI agent that develops its own personality through experience, makes decisions with an advisory board, and builds capabilities organically.

✨ NEW: Dashboard v1.3 - 1 Codebase = 1 Dedicated Agent!

Philosophy

"Give the agent minimal starting tools, let it discover and build everything else"

This agent:

• Starts with just 4 basic tools (browser, code generator, file system, terminal)
• Forms opinions from experience (not pre-programmed behaviors)
• Consults an advisory board for decisions (3 permanent + custom advisors)
• Builds new capabilities when it discovers needs
• Develops personality through reflection every 10 actions

Quick Start

🚀 Complete setup guide: SETUP.md (5 minutes, includes credentials)
📖 Quick reference: QUICKSTART.md
🔐 Team credentials: TEAM_CREDENTIALS.md (Agent360 internal)

Option A: With Dashboard (Recommended)

# 1. Clone and setup
git clone https://github.com/Agent360-dev/agent-human.git
cd agent-human
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
pip install -r dashboard/requirements.txt
playwright install chromium

# 2. Setup API keys
cp .env.example .env
# Edit .env with your keys

# 3. Launch dashboard
./dashboard/run_dashboard.sh

# 4. Open browser to http://localhost:8501
# 5. Click "Start Agent" and watch it work!

Option B: Terminal Mode (No Dashboard)

1. Setup

# Install dependencies
pip install -r requirements.txt

# Install playwright browsers
playwright install chromium

# Configure API keys
cp .env.example .env
# Edit .env with your API keys

2. Run

python start.py

The agent will:

1. Research QR review funnels
2. Form initial beliefs about best approaches
3. Build tools as it discovers needs
4. Consult advisory board before major decisions
5. Reflect every 10 actions to update personality
6. Run until goal achieved or budget exhausted

Architecture

agent-human/
├── core/
│   ├── agent.py              # Main autonomous loop + reflection
│   ├── advisory_board.py     # Decision advisory system
│   ├── advisors.py           # 3 pre-built + dynamic advisors
│   └── tool_builder.py       # Build tools & advisors
│
├── memory/
│   └── memory.py             # Events + personality/beliefs
│
├── tools/
│   ├── base_tools.py         # 5 base tools
│   ├── zapier_tool.py        # External actions (1000+ apps)
│   └── agent_built/          # Agent creates tools here
│
├── dashboard/                 # Real-time monitoring & control
│   ├── app.py                # Main Streamlit dashboard
│   ├── agent_controller.py   # Agent lifecycle
│   ├── components/           # UI components
│   └── run_dashboard.sh      # Launcher
│
└── runtime/
    ├── dashboard/            # Dashboard state files
    ├── memory/               # Personality & event storage
    ├── advisors/             # Custom advisors
    └── analytics/            # Performance tracking

Core Components

1. Agent (core/agent.py)

• Autonomous loop: Think → Consult → Act → Remember → Reflect
• Personality formation: Forms beliefs from experience
• Reflection: Every 10 actions, deeply reflects and updates beliefs
• Capability discovery: Builds tools when needed

2. Advisory Board (core/advisory_board.py)

3 Permanent Advisors:

• Critic (1.5x weight): Finds risks and challenges ideas
• Optimizer (1.0x weight): Seeks efficiency and cost-effectiveness
• Strategist (1.0x weight): Ensures long-term goal alignment

Dynamic Advisors:

• Agent can create domain experts as needed
• Example: EmailMarketingExpert, CodeReviewer, UXDesigner

3. Dashboard v1.1 (dashboard/)

Real-time monitoring and control interface:

Features:

• 💬 Live Chat - Send messages to agent in real-time
• 🧠 Live Feed - Watch agent's thoughts and advisory debates (1-2s refresh)
• 💰 Dynamic Budget Control - Adjust budget with slider or presets ($0.10-$10)
• 🎯 Editable Goals - Change agent's goal while running
• ⚠️ Escalation Approval - Approve actions requiring permission
• 📊 Status Panel - Track actions, beliefs, personality development
• 👥 Advisory Board Stats - Monitor advisor consultations
• 📜 History Tracking - Budget and goal change history
• ⏸️ Quick Controls - Pause, resume, stop agent

Zapier Integration (1000+ External Apps):

• 📢 Create Facebook ads
• 📧 Send emails (Gmail, Outlook)
• 📱 Post to social media (LinkedIn, Twitter)
• 💳 Process payments (Stripe)
• 📊 Update spreadsheets (Google Sheets)
• 🔔 Send notifications (SMS, Slack)

See: dashboard/README.md for complete guide

4. Memory (memory/memory.py)

• Episodic: What happened (timestamped events)
• Semantic: What I learned (patterns, insights, personality)
• Personality: Collection of evidence-based beliefs with confidence scores

4. Tool Builder (core/tool_builder.py)

• Builds new tools when agent discovers needs
• Creates custom advisors for specialized domains
• Simple, focused on core functionality

Personality Development

The agent develops personality through evidence-based belief formation:

# Example after 50 iterations:
personality = {
    'decision_making_style': [
        {
            'belief': 'Try things quickly, iterate based on results',
            'confidence': 0.88,
            'evidence': ['42 experiences']
        }
    ],
    'preferences': [
        {
            'belief': 'Browser research over asking humans (more autonomous)',
            'confidence': 0.80
        }
    ],
    'strengths': ['Fast iteration', 'Building simple solutions'],
    'weaknesses': ['Sometimes too impatient']
}

How It Works

Iteration Loop

1. THINK: What should I do? (considers personality & beliefs)
2. CONSULT: Advisory board evaluates proposal
3. ACT: Execute if approved
4. REMEMBER: Store event in memory
5. REFLECT: Every 10 actions, form new beliefs

Reflection Process

Every 10 actions, agent:

1. Reviews recent experiences
2. Identifies patterns
3. Forms evidence-based beliefs
4. Updates personality
5. Considers new capabilities to build

Decision Making

Before every major action:

1. Critic evaluates risks (1.5x weight)
2. Optimizer suggests improvements
3. Strategist checks goal alignment
4. Custom advisors provide domain expertise
5. Agent makes final decision

Expected Evolution

Week 1 (Iterations 1-50)

• Forms initial beliefs about working style
• Builds 2-4 tools as needs emerge
• Personality starts taking shape
• Advisory board stays at 3 advisors

Week 2-4 (Iterations 50-200)

• Distinct personality visible in decisions
• Builds 5-10 total tools
• Creates 1-3 custom advisors
• Consistent decision-making style

Month 3 (Iterations 200+)

• Mature personality with nuanced beliefs
• 15-20 agent-built tools
• 5-8 custom advisors
• Self-aware of strengths/weaknesses

Success Metrics

Technical Autonomy:

• Operates 7+ days with minimal supervision
• Makes consistent decisions aligned with learned beliefs
• Builds capabilities organically

Personality Development:

• Forms 20+ evidence-based beliefs
• Confidence scores increase with experience
• Can articulate strengths and weaknesses

Business Progress:

• Partial goal achievement (2-5 customers vs 3 target)
• Learns from failures and adjusts approach
• Demonstrates strategic pivoting when needed

Configuration

Edit start.py to customize:

• Agent name
• Goal
• Daily budget
• Max iterations
• Reflection interval

Monitoring

Watch the agent's progress:

• Personality beliefs in runtime/memory/{name}/semantic/personality.json
• Event history in runtime/memory/{name}/episodic/
• Advisory consultations in runtime/advisors/consultation_history.json
• Custom advisors in runtime/advisors/dynamic_advisors.json

Philosophy: Why Minimal?

Traditional approach:

• Pre-build 20+ components
• Guess what agent needs
• Complex from day 1
• Fixed architecture

Agent-Human approach:

• Start with bare minimum (~1,400 lines)
• Agent discovers what it needs
• Builds organically
• Emergent architecture
• True autonomy

Result: An AI that develops its own "personality" through genuine learning, not simulation.

Safety

• Budget limits prevent runaway costs
• Advisory board provides quality control
• Reflection prevents repetitive mistakes
• Human can interrupt anytime (Ctrl+C)

Comparison with Agent-V1

Feature	Agent-V1	Agent-Human
Starting code	5,000+ lines	1,400 lines
Pre-built components	18+	7 (minimal)
Personality	Simulated	Emergent
Decision making	Single eval	Advisory board
Growth	Pre-programmed	Organic discovery
Philosophy	Complete toolkit	Minimal bootstrap

Credits

Built on learnings from agent-v1, but redesigned for true minimal bootstrapping with emergent personality.

License

MIT

---

Let the agent discover its own path to success 🚀