convez.ai
MCP ServerAutomaçãoAvançado
socket-link

Ampere

socket-link/ampere

Veja o cérebro transparente de seus agentes IA em tempo real

Ver no GitHub
BomPluginScore · de 0 a 100

Framework Kotlin Multiplatform para observabilidade de cognição em IA, onde cada decisão de agente emite eventos estruturados e consultáveis em tempo real. Permite coordenação reativa entre múltiplos agentes paralelos através de uma arquitetura aberta que expõe o raciocínio conforme ele se forma.

Instalação

$npx convez-ai socket-link/ampere

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
40
Forks
5
Acompanhando
3
Saúde
62%
Último commit
há 2 semanas
Versão
v0.26.0
Issues abertas
9
Contribuidores
3

Casos de uso

  • Coordenação e orquestração de múltiplos agentes IA
  • Debugging e auditoria de decisões de agentes
  • Monitoramento em tempo real do raciocínio de IA
  • Construção de sistemas multi-agente reativos

Veredito

Solução robusta e tecnicamente sólida para quem precisa observar e coordenar múltiplos agentes IA. Arquitetura bem pensada com observabilidade nativa, mas requer conhecimento sólido de Kotlin e sistemas distribuídos para explorar todo seu potencial.

README

A tradução para o português deste README ainda está na fila.

⚡ AMPERE

Peer into your AI's glass brain.

Maven Central License Build

Ampere is a Kotlin Multiplatform framework where every agent decision emits a structured, queryable event — providing real-time cognition observability around AI actions that is built into the core of the architecture, rather than being bolted-on after the fact.

When Ampere runs multiple agents in parallel, this open architecture allows each agent to observe, coordinate, and react to the reasoning of others as it forms — making multi-agent coordination reactive rather than scripted.


Quick Start

Prerequisites: Java 21+ (run java -version to check)

Run agents from the command line (ampere-cli)

Build CLI

# <!--- Option 1: Installation from source --->
#
# 1. Clone the project
git clone https://github.com/socket-link/ampere.git
cd ampere

# 2. Configure LLM provider API keys in `local.properties`
cp ampere-cli/local.properties.example ampere-cli/local.properties
nano ampere-cli/local.properties

# 3. Build the CLI
./gradlew :ampere-cli:installDist

# 4. Add `ampere` to your PATH for easy access from your project
export PATH="$PATH:$(pwd)/ampere-cli/build/install/ampere-jvm/bin"


# <!--- Option 2: Install prebuilt binaries --->
#
# Coming soon!

Configure Project

# 1. Copy the example `ampere.yaml` config into your <project> directory
cp ampere/ampere.example.yaml <project>/ampere.yaml

# 2. Make any necessary adjustments to the default agent configuration
nano <project>/ampere.yaml

All Configuration Options →

Start Ampere

# Runs Ampere with a goal — this launches the TUI, and agents begin to communicate
cd <project>
ampere --goal "Add comprehensive documentation with interactive examples"

The dashboard then displays all agent cognition in real time: perception, recall, optimization, planning, execution, and coordination.

To change focus between panes in the CLI, press

  • d for runtime overview
  • e for event stream
  • m for agent memory

Press ? for more options.

Full Usage Guide →

Embed in your Kotlin project (ampere-core)

Add to your project:

// build.gradle.kts
dependencies {
    implementation("link.socket:ampere-core:0.1.1")
}
val team = AgentTeam.create {
    // Configure your AI provider
    config(
        AnthropicConfig(
            apiKey = System.getenv("ANTHROPIC_API_KEY"),
            model = Claude.Sonnet4,
        ),
    )

    // Add agents with personality traits
    agent(ProductManager) { personality { directness = 0.8 } }
    agent(Engineer) { personality { creativity = 0.7 } }
    agent(QATester)
}

// Assign a goal and observe the event stream
team.goal("Build a user authentication system")

team.events.collect { event ->
    when (event) {
        is Perceived -> println("${event.agent} noticed: ${event.signal}")
        is Recalled -> println("${event.agent} remembered: ${event.memory}")
        is Planned -> println("${event.agent} decided: ${event.plan}")
        is Executed -> println("${event.agent} did: ${event.action}")
        is Escalated -> println("${event.agent} needs help: ${event.reason}")
    }
}

apiKey is optional. When you provide it, Ampere uses that runtime credential directly. When you omit it, provider clients fall back to the generated KotlinConfig values sourced from local.properties at build time.


Why Ampere?

Most agent frameworks bolt on observability after the fact — attaching tools like LangSmith or Langfuse to reconstruct behavior from traces.

Ampere inverts this. Every cognitive phase emits structured events as a natural consequence of its architecture. This isn't just for debugging — it's what enables agents to coordinate. When Agent B can observe Agent A's reasoning as it forms, coordination becomes reactive rather than scripted.

Post-hoc ObservabilityAmpere Observability
Reconstruct behavior from tracesDecisions are observable as they form
Observe from outside the agentCognition emits structured events
Uncertainty hidden in token probabilitiesUncertainty surfaces and escalates
Memory is an implementation detailMemory operations are first-class events

When agent confidence for a plan drops below a configurable threshold, agents are able to escalate to a human, surfacing exactly what they're uncertain about.

This allows you to steer the agent toward an informed decision in real-time, rather than needing to debug opaque failures after the fact.

Coordination Primitives

ConceptObservable SurfacePurpose
TicketsGoals and their lifecycleTrack work from creation to close
TasksDiscrete execution stepsTrace every action an agent performs
PlansStructured decision logicInspect reasoning before execution
MeetingsInter-agent coordinationAudit how agents negotiate and align
OutcomesExecution resultsQuery historical performance
KnowledgeAccumulated understandingSearch what agents have learned

Core Concepts Guide →

The PROPEL Cognitive Loop

During each timestep of the environment simulation, each agent executes its own independent cognitive cycle:

1. Perceive  ──▶  2. Recall  ──▶  3. Observe

       ▲                               │
       │                               ▼

    6. Learn  ◀──  5. Execute  ◀──  4. Plan
#PhaseOperationEmitted Events
1(P)erceiveIngest signals from the environmentSignalReceived, PerceptionFormed
2(R)ecallQuery relevant memory and contextMemoryQueried, ContextAssembled
3(O)bserveRead current state and detect driftStateObserved, DriftDetected
4(P)lanSelect and structure actionsPlanCreated, TasksDecomposed
5(E)xecuteCarry out the planActionTaken, ResultObserved
6(L)earnExtract knowledge, re-enter cycleOutcomeEvaluated, KnowledgeStored

Every phase transition is emitted as an event, ensuring every action inside an agent can be audited and traced.

Full Cognitive Lifecycle →

Full Documentation

GuideDescription
CLI ReferenceCommand-line tools
Core ConceptsThe observable cognition primitives
Concept CellsPer-primitive invariants and rationale
Agent LifecycleThe PROPEL loop in detail
ArchitectureSystem architecture overview
ContributingHow to contribute to the project

Developer setup

After cloning the repo, install the optional pre-push hook that warns when a push touches files listed under a concept cell's tracked_sources without updating the concept file:

./scripts/install-hooks.sh

The hook calls scripts/validate-concepts.sh and is informational only — it never blocks a push. Re-running the installer is idempotent. To suppress a warning when your change confirms an existing concept, include the trailer Concept-Verified: <ConceptName> in your commit message.


License

Apache 2.0 — see LICENSE.txt for more details.

Copyright 2026 Miley Chandonnet, Stedfast Softworks LLC

Ver o original no GitHub

Bom para

Relacionados